Amazon AppStream

POST AssociateApplicationFleet

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateApplicationFleet

HEADERS

X-Amz-Target

BODY json

{
  "FleetName": "",
  "ApplicationArn": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateApplicationFleet" {:headers {:x-amz-target ""}
                                                                                                            :content-type :json
                                                                                                            :form-params {:FleetName ""
                                                                                                                          :ApplicationArn ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateApplicationFleet"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\"\n}"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateApplicationFleet"

	payload := strings.NewReader("{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\"\n}")

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

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

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

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

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

}

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

{
  "FleetName": "",
  "ApplicationArn": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

const data = JSON.stringify({
  FleetName: '',
  ApplicationArn: ''
});

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=PhotonAdminProxyService.AssociateApplicationFleet');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateApplicationFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {FleetName: '', ApplicationArn: ''}
};

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({FleetName: '', ApplicationArn: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateApplicationFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {FleetName: '', ApplicationArn: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  FleetName: '',
  ApplicationArn: ''
});

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=PhotonAdminProxyService.AssociateApplicationFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {FleetName: '', ApplicationArn: ''}
};

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

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

#import 

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

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

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

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

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

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

curl_close($curl);

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

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

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'FleetName' => '',
  'ApplicationArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateApplicationFleet');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

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

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

import http.client

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

payload = "{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateApplicationFleet"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateApplicationFleet"

payload <- "{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "FleetName": "",
        "ApplicationArn": ""
    });

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

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateApplicationFleet' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "FleetName": "",
  "ApplicationArn": ""
}'

echo '{
  "FleetName": "",
  "ApplicationArn": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateApplicationFleet' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST AssociateApplicationToEntitlement

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateApplicationToEntitlement

HEADERS

X-Amz-Target

BODY json

{
  "StackName": "",
  "EntitlementName": "",
  "ApplicationIdentifier": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"ApplicationIdentifier\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateApplicationToEntitlement" {:headers {:x-amz-target ""}
                                                                                                                    :content-type :json
                                                                                                                    :form-params {:StackName ""
                                                                                                                                  :EntitlementName ""
                                                                                                                                  :ApplicationIdentifier ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateApplicationToEntitlement"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"ApplicationIdentifier\": \"\"\n}"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateApplicationToEntitlement"

	payload := strings.NewReader("{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"ApplicationIdentifier\": \"\"\n}")

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

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

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

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

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

}

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

{
  "StackName": "",
  "EntitlementName": "",
  "ApplicationIdentifier": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateApplicationToEntitlement")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"ApplicationIdentifier\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  StackName: '',
  EntitlementName: '',
  ApplicationIdentifier: ''
});

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=PhotonAdminProxyService.AssociateApplicationToEntitlement');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateApplicationToEntitlement',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {StackName: '', EntitlementName: '', ApplicationIdentifier: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateApplicationToEntitlement';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"StackName":"","EntitlementName":"","ApplicationIdentifier":""}'
};

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({StackName: '', EntitlementName: '', ApplicationIdentifier: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateApplicationToEntitlement',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {StackName: '', EntitlementName: '', ApplicationIdentifier: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  StackName: '',
  EntitlementName: '',
  ApplicationIdentifier: ''
});

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=PhotonAdminProxyService.AssociateApplicationToEntitlement',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {StackName: '', EntitlementName: '', ApplicationIdentifier: ''}
};

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=PhotonAdminProxyService.AssociateApplicationToEntitlement';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"StackName":"","EntitlementName":"","ApplicationIdentifier":""}'
};

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

#import 

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

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

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

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

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

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateApplicationToEntitlement', [
  'body' => '{
  "StackName": "",
  "EntitlementName": "",
  "ApplicationIdentifier": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'StackName' => '',
  'EntitlementName' => '',
  'ApplicationIdentifier' => ''
]));

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

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

append(json_encode([
  'StackName' => '',
  'EntitlementName' => '',
  'ApplicationIdentifier' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateApplicationToEntitlement');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

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

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

import http.client

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

payload = "{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"ApplicationIdentifier\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateApplicationToEntitlement"

payload = {
    "StackName": "",
    "EntitlementName": "",
    "ApplicationIdentifier": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateApplicationToEntitlement"

payload <- "{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"ApplicationIdentifier\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "StackName": "",
        "EntitlementName": "",
        "ApplicationIdentifier": ""
    });

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

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateApplicationToEntitlement' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "StackName": "",
  "EntitlementName": "",
  "ApplicationIdentifier": ""
}'

echo '{
  "StackName": "",
  "EntitlementName": "",
  "ApplicationIdentifier": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateApplicationToEntitlement' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "StackName": "",\n  "EntitlementName": "",\n  "ApplicationIdentifier": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateApplicationToEntitlement'

import Foundation

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

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

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST AssociateFleet

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateFleet

HEADERS

X-Amz-Target

BODY json

{
  "FleetName": "",
  "StackName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"FleetName\": \"\",\n  \"StackName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateFleet" {:headers {:x-amz-target ""}
                                                                                                 :content-type :json
                                                                                                 :form-params {:FleetName ""
                                                                                                               :StackName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateFleet"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"FleetName\": \"\",\n  \"StackName\": \"\"\n}"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateFleet"

	payload := strings.NewReader("{\n  \"FleetName\": \"\",\n  \"StackName\": \"\"\n}")

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

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

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

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

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

}

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

{
  "FleetName": "",
  "StackName": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

const data = JSON.stringify({
  FleetName: '',
  StackName: ''
});

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=PhotonAdminProxyService.AssociateFleet');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {FleetName: '', StackName: ''}
};

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({FleetName: '', StackName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {FleetName: '', StackName: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  FleetName: '',
  StackName: ''
});

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=PhotonAdminProxyService.AssociateFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {FleetName: '', StackName: ''}
};

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

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

#import 

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

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

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

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

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

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

curl_close($curl);

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

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

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'FleetName' => '',
  'StackName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateFleet');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

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

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

import http.client

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

payload = "{\n  \"FleetName\": \"\",\n  \"StackName\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateFleet"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateFleet"

payload <- "{\n  \"FleetName\": \"\",\n  \"StackName\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "FleetName": "",
        "StackName": ""
    });

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

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateFleet' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "FleetName": "",
  "StackName": ""
}'

echo '{
  "FleetName": "",
  "StackName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.AssociateFleet' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST BatchAssociateUserStack

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.BatchAssociateUserStack

HEADERS

X-Amz-Target

BODY json

{
  "UserStackAssociations": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.BatchAssociateUserStack"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserStackAssociations\": \"\"\n}"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.BatchAssociateUserStack"

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

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

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

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

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

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

}

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

{
  "UserStackAssociations": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

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

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=PhotonAdminProxyService.BatchAssociateUserStack');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

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

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({UserStackAssociations: ''}));
req.end();

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

#import 

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

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

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

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

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

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

curl_close($curl);

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

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

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'UserStackAssociations' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.BatchAssociateUserStack');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

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

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

import http.client

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

payload = "{\n  \"UserStackAssociations\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.BatchAssociateUserStack"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.BatchAssociateUserStack"

payload <- "{\n  \"UserStackAssociations\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

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

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

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.BatchAssociateUserStack' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserStackAssociations": ""
}'

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

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

import Foundation

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

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

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST BatchDisassociateUserStack

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.BatchDisassociateUserStack

HEADERS

X-Amz-Target

BODY json

{
  "UserStackAssociations": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.BatchDisassociateUserStack"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserStackAssociations\": \"\"\n}"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.BatchDisassociateUserStack"

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

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

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

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

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

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

}

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

{
  "UserStackAssociations": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

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

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=PhotonAdminProxyService.BatchDisassociateUserStack');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

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

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({UserStackAssociations: ''}));
req.end();

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

#import 

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

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

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

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

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

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

curl_close($curl);

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

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

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'UserStackAssociations' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.BatchDisassociateUserStack');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

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

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

import http.client

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

payload = "{\n  \"UserStackAssociations\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.BatchDisassociateUserStack"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.BatchDisassociateUserStack"

payload <- "{\n  \"UserStackAssociations\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

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

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

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.BatchDisassociateUserStack' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserStackAssociations": ""
}'

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

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

import Foundation

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

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

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CopyImage

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CopyImage

HEADERS

X-Amz-Target

BODY json

{
  "SourceImageName": "",
  "DestinationImageName": "",
  "DestinationRegion": "",
  "DestinationImageDescription": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"SourceImageName\": \"\",\n  \"DestinationImageName\": \"\",\n  \"DestinationRegion\": \"\",\n  \"DestinationImageDescription\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CopyImage" {:headers {:x-amz-target ""}
                                                                                            :content-type :json
                                                                                            :form-params {:SourceImageName ""
                                                                                                          :DestinationImageName ""
                                                                                                          :DestinationRegion ""
                                                                                                          :DestinationImageDescription ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CopyImage"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"SourceImageName\": \"\",\n  \"DestinationImageName\": \"\",\n  \"DestinationRegion\": \"\",\n  \"DestinationImageDescription\": \"\"\n}"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CopyImage"

	payload := strings.NewReader("{\n  \"SourceImageName\": \"\",\n  \"DestinationImageName\": \"\",\n  \"DestinationRegion\": \"\",\n  \"DestinationImageDescription\": \"\"\n}")

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

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

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

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

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

}

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

{
  "SourceImageName": "",
  "DestinationImageName": "",
  "DestinationRegion": "",
  "DestinationImageDescription": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CopyImage")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"SourceImageName\": \"\",\n  \"DestinationImageName\": \"\",\n  \"DestinationRegion\": \"\",\n  \"DestinationImageDescription\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  SourceImageName: '',
  DestinationImageName: '',
  DestinationRegion: '',
  DestinationImageDescription: ''
});

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=PhotonAdminProxyService.CopyImage');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CopyImage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    SourceImageName: '',
    DestinationImageName: '',
    DestinationRegion: '',
    DestinationImageDescription: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CopyImage';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SourceImageName":"","DestinationImageName":"","DestinationRegion":"","DestinationImageDescription":""}'
};

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=PhotonAdminProxyService.CopyImage',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "SourceImageName": "",\n  "DestinationImageName": "",\n  "DestinationRegion": "",\n  "DestinationImageDescription": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"SourceImageName\": \"\",\n  \"DestinationImageName\": \"\",\n  \"DestinationRegion\": \"\",\n  \"DestinationImageDescription\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CopyImage")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  SourceImageName: '',
  DestinationImageName: '',
  DestinationRegion: '',
  DestinationImageDescription: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CopyImage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    SourceImageName: '',
    DestinationImageName: '',
    DestinationRegion: '',
    DestinationImageDescription: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  SourceImageName: '',
  DestinationImageName: '',
  DestinationRegion: '',
  DestinationImageDescription: ''
});

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=PhotonAdminProxyService.CopyImage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    SourceImageName: '',
    DestinationImageName: '',
    DestinationRegion: '',
    DestinationImageDescription: ''
  }
};

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=PhotonAdminProxyService.CopyImage';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SourceImageName":"","DestinationImageName":"","DestinationRegion":"","DestinationImageDescription":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"SourceImageName": @"",
                              @"DestinationImageName": @"",
                              @"DestinationRegion": @"",
                              @"DestinationImageDescription": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CopyImage" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"SourceImageName\": \"\",\n  \"DestinationImageName\": \"\",\n  \"DestinationRegion\": \"\",\n  \"DestinationImageDescription\": \"\"\n}" in

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

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

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CopyImage', [
  'body' => '{
  "SourceImageName": "",
  "DestinationImageName": "",
  "DestinationRegion": "",
  "DestinationImageDescription": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'SourceImageName' => '',
  'DestinationImageName' => '',
  'DestinationRegion' => '',
  'DestinationImageDescription' => ''
]));

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

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

append(json_encode([
  'SourceImageName' => '',
  'DestinationImageName' => '',
  'DestinationRegion' => '',
  'DestinationImageDescription' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CopyImage');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CopyImage' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SourceImageName": "",
  "DestinationImageName": "",
  "DestinationRegion": "",
  "DestinationImageDescription": ""
}'

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

import http.client

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

payload = "{\n  \"SourceImageName\": \"\",\n  \"DestinationImageName\": \"\",\n  \"DestinationRegion\": \"\",\n  \"DestinationImageDescription\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CopyImage"

payload = {
    "SourceImageName": "",
    "DestinationImageName": "",
    "DestinationRegion": "",
    "DestinationImageDescription": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CopyImage"

payload <- "{\n  \"SourceImageName\": \"\",\n  \"DestinationImageName\": \"\",\n  \"DestinationRegion\": \"\",\n  \"DestinationImageDescription\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "SourceImageName": "",
        "DestinationImageName": "",
        "DestinationRegion": "",
        "DestinationImageDescription": ""
    });

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

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CopyImage' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "SourceImageName": "",
  "DestinationImageName": "",
  "DestinationRegion": "",
  "DestinationImageDescription": ""
}'

echo '{
  "SourceImageName": "",
  "DestinationImageName": "",
  "DestinationRegion": "",
  "DestinationImageDescription": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CopyImage' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "SourceImageName": "",\n  "DestinationImageName": "",\n  "DestinationRegion": "",\n  "DestinationImageDescription": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CopyImage'

import Foundation

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

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

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateAppBlock

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateAppBlock

HEADERS

X-Amz-Target

BODY json

{
  "Name": "",
  "Description": "",
  "DisplayName": "",
  "SourceS3Location": "",
  "SetupScriptDetails": "",
  "Tags": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"SourceS3Location\": \"\",\n  \"SetupScriptDetails\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateAppBlock" {:headers {:x-amz-target ""}
                                                                                                 :content-type :json
                                                                                                 :form-params {:Name ""
                                                                                                               :Description ""
                                                                                                               :DisplayName ""
                                                                                                               :SourceS3Location ""
                                                                                                               :SetupScriptDetails ""
                                                                                                               :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateAppBlock"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"SourceS3Location\": \"\",\n  \"SetupScriptDetails\": \"\",\n  \"Tags\": \"\"\n}"

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

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

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateAppBlock");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"SourceS3Location\": \"\",\n  \"SetupScriptDetails\": \"\",\n  \"Tags\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateAppBlock"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"SourceS3Location\": \"\",\n  \"SetupScriptDetails\": \"\",\n  \"Tags\": \"\"\n}")

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

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

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

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

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

}

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

{
  "Name": "",
  "Description": "",
  "DisplayName": "",
  "SourceS3Location": "",
  "SetupScriptDetails": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateAppBlock")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"SourceS3Location\": \"\",\n  \"SetupScriptDetails\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"SourceS3Location\": \"\",\n  \"SetupScriptDetails\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateAppBlock")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateAppBlock")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"SourceS3Location\": \"\",\n  \"SetupScriptDetails\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Description: '',
  DisplayName: '',
  SourceS3Location: '',
  SetupScriptDetails: '',
  Tags: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateAppBlock',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    DisplayName: '',
    SourceS3Location: '',
    SetupScriptDetails: '',
    Tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateAppBlock';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","Description":"","DisplayName":"","SourceS3Location":"","SetupScriptDetails":"","Tags":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateAppBlock',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Description": "",\n  "DisplayName": "",\n  "SourceS3Location": "",\n  "SetupScriptDetails": "",\n  "Tags": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"SourceS3Location\": \"\",\n  \"SetupScriptDetails\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateAppBlock")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  Name: '',
  Description: '',
  DisplayName: '',
  SourceS3Location: '',
  SetupScriptDetails: '',
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateAppBlock',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    Name: '',
    Description: '',
    DisplayName: '',
    SourceS3Location: '',
    SetupScriptDetails: '',
    Tags: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  Name: '',
  Description: '',
  DisplayName: '',
  SourceS3Location: '',
  SetupScriptDetails: '',
  Tags: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateAppBlock',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    DisplayName: '',
    SourceS3Location: '',
    SetupScriptDetails: '',
    Tags: ''
  }
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateAppBlock';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","Description":"","DisplayName":"","SourceS3Location":"","SetupScriptDetails":"","Tags":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"Description": @"",
                              @"DisplayName": @"",
                              @"SourceS3Location": @"",
                              @"SetupScriptDetails": @"",
                              @"Tags": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateAppBlock" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"SourceS3Location\": \"\",\n  \"SetupScriptDetails\": \"\",\n  \"Tags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateAppBlock",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'Description' => '',
    'DisplayName' => '',
    'SourceS3Location' => '',
    'SetupScriptDetails' => '',
    'Tags' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateAppBlock', [
  'body' => '{
  "Name": "",
  "Description": "",
  "DisplayName": "",
  "SourceS3Location": "",
  "SetupScriptDetails": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Description' => '',
  'DisplayName' => '',
  'SourceS3Location' => '',
  'SetupScriptDetails' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'Name' => '',
  'Description' => '',
  'DisplayName' => '',
  'SourceS3Location' => '',
  'SetupScriptDetails' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateAppBlock');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateAppBlock' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "DisplayName": "",
  "SourceS3Location": "",
  "SetupScriptDetails": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateAppBlock' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "DisplayName": "",
  "SourceS3Location": "",
  "SetupScriptDetails": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"SourceS3Location\": \"\",\n  \"SetupScriptDetails\": \"\",\n  \"Tags\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateAppBlock"

payload = {
    "Name": "",
    "Description": "",
    "DisplayName": "",
    "SourceS3Location": "",
    "SetupScriptDetails": "",
    "Tags": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateAppBlock"

payload <- "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"SourceS3Location\": \"\",\n  \"SetupScriptDetails\": \"\",\n  \"Tags\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"SourceS3Location\": \"\",\n  \"SetupScriptDetails\": \"\",\n  \"Tags\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"SourceS3Location\": \"\",\n  \"SetupScriptDetails\": \"\",\n  \"Tags\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "Name": "",
        "Description": "",
        "DisplayName": "",
        "SourceS3Location": "",
        "SetupScriptDetails": "",
        "Tags": ""
    });

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

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateAppBlock' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": "",
  "Description": "",
  "DisplayName": "",
  "SourceS3Location": "",
  "SetupScriptDetails": "",
  "Tags": ""
}'

echo '{
  "Name": "",
  "Description": "",
  "DisplayName": "",
  "SourceS3Location": "",
  "SetupScriptDetails": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateAppBlock' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Description": "",\n  "DisplayName": "",\n  "SourceS3Location": "",\n  "SetupScriptDetails": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateAppBlock'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "Description": "",
  "DisplayName": "",
  "SourceS3Location": "",
  "SetupScriptDetails": "",
  "Tags": ""
] as [String : Any]

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

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateApplication

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

HEADERS

X-Amz-Target

BODY json

{
  "Name": "",
  "DisplayName": "",
  "Description": "",
  "IconS3Location": "",
  "LaunchPath": "",
  "WorkingDirectory": "",
  "LaunchParameters": "",
  "Platforms": "",
  "InstanceFamilies": "",
  "AppBlockArn": "",
  "Tags": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"Platforms\": \"\",\n  \"InstanceFamilies\": \"\",\n  \"AppBlockArn\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateApplication" {:headers {:x-amz-target ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:Name ""
                                                                                                                  :DisplayName ""
                                                                                                                  :Description ""
                                                                                                                  :IconS3Location ""
                                                                                                                  :LaunchPath ""
                                                                                                                  :WorkingDirectory ""
                                                                                                                  :LaunchParameters ""
                                                                                                                  :Platforms ""
                                                                                                                  :InstanceFamilies ""
                                                                                                                  :AppBlockArn ""
                                                                                                                  :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateApplication"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"Platforms\": \"\",\n  \"InstanceFamilies\": \"\",\n  \"AppBlockArn\": \"\",\n  \"Tags\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateApplication"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"Platforms\": \"\",\n  \"InstanceFamilies\": \"\",\n  \"AppBlockArn\": \"\",\n  \"Tags\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateApplication");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"Platforms\": \"\",\n  \"InstanceFamilies\": \"\",\n  \"AppBlockArn\": \"\",\n  \"Tags\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"Platforms\": \"\",\n  \"InstanceFamilies\": \"\",\n  \"AppBlockArn\": \"\",\n  \"Tags\": \"\"\n}")

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

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

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

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

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

}

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

{
  "Name": "",
  "DisplayName": "",
  "Description": "",
  "IconS3Location": "",
  "LaunchPath": "",
  "WorkingDirectory": "",
  "LaunchParameters": "",
  "Platforms": "",
  "InstanceFamilies": "",
  "AppBlockArn": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateApplication")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"Platforms\": \"\",\n  \"InstanceFamilies\": \"\",\n  \"AppBlockArn\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateApplication"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"Platforms\": \"\",\n  \"InstanceFamilies\": \"\",\n  \"AppBlockArn\": \"\",\n  \"Tags\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"Platforms\": \"\",\n  \"InstanceFamilies\": \"\",\n  \"AppBlockArn\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateApplication")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateApplication")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"Platforms\": \"\",\n  \"InstanceFamilies\": \"\",\n  \"AppBlockArn\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  DisplayName: '',
  Description: '',
  IconS3Location: '',
  LaunchPath: '',
  WorkingDirectory: '',
  LaunchParameters: '',
  Platforms: '',
  InstanceFamilies: '',
  AppBlockArn: '',
  Tags: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    DisplayName: '',
    Description: '',
    IconS3Location: '',
    LaunchPath: '',
    WorkingDirectory: '',
    LaunchParameters: '',
    Platforms: '',
    InstanceFamilies: '',
    AppBlockArn: '',
    Tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateApplication';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","DisplayName":"","Description":"","IconS3Location":"","LaunchPath":"","WorkingDirectory":"","LaunchParameters":"","Platforms":"","InstanceFamilies":"","AppBlockArn":"","Tags":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateApplication',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "DisplayName": "",\n  "Description": "",\n  "IconS3Location": "",\n  "LaunchPath": "",\n  "WorkingDirectory": "",\n  "LaunchParameters": "",\n  "Platforms": "",\n  "InstanceFamilies": "",\n  "AppBlockArn": "",\n  "Tags": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"Platforms\": \"\",\n  \"InstanceFamilies\": \"\",\n  \"AppBlockArn\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateApplication")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  Name: '',
  DisplayName: '',
  Description: '',
  IconS3Location: '',
  LaunchPath: '',
  WorkingDirectory: '',
  LaunchParameters: '',
  Platforms: '',
  InstanceFamilies: '',
  AppBlockArn: '',
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    Name: '',
    DisplayName: '',
    Description: '',
    IconS3Location: '',
    LaunchPath: '',
    WorkingDirectory: '',
    LaunchParameters: '',
    Platforms: '',
    InstanceFamilies: '',
    AppBlockArn: '',
    Tags: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  Name: '',
  DisplayName: '',
  Description: '',
  IconS3Location: '',
  LaunchPath: '',
  WorkingDirectory: '',
  LaunchParameters: '',
  Platforms: '',
  InstanceFamilies: '',
  AppBlockArn: '',
  Tags: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    DisplayName: '',
    Description: '',
    IconS3Location: '',
    LaunchPath: '',
    WorkingDirectory: '',
    LaunchParameters: '',
    Platforms: '',
    InstanceFamilies: '',
    AppBlockArn: '',
    Tags: ''
  }
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateApplication';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","DisplayName":"","Description":"","IconS3Location":"","LaunchPath":"","WorkingDirectory":"","LaunchParameters":"","Platforms":"","InstanceFamilies":"","AppBlockArn":"","Tags":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"DisplayName": @"",
                              @"Description": @"",
                              @"IconS3Location": @"",
                              @"LaunchPath": @"",
                              @"WorkingDirectory": @"",
                              @"LaunchParameters": @"",
                              @"Platforms": @"",
                              @"InstanceFamilies": @"",
                              @"AppBlockArn": @"",
                              @"Tags": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateApplication" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"Platforms\": \"\",\n  \"InstanceFamilies\": \"\",\n  \"AppBlockArn\": \"\",\n  \"Tags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateApplication",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'DisplayName' => '',
    'Description' => '',
    'IconS3Location' => '',
    'LaunchPath' => '',
    'WorkingDirectory' => '',
    'LaunchParameters' => '',
    'Platforms' => '',
    'InstanceFamilies' => '',
    'AppBlockArn' => '',
    'Tags' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateApplication', [
  'body' => '{
  "Name": "",
  "DisplayName": "",
  "Description": "",
  "IconS3Location": "",
  "LaunchPath": "",
  "WorkingDirectory": "",
  "LaunchParameters": "",
  "Platforms": "",
  "InstanceFamilies": "",
  "AppBlockArn": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'DisplayName' => '',
  'Description' => '',
  'IconS3Location' => '',
  'LaunchPath' => '',
  'WorkingDirectory' => '',
  'LaunchParameters' => '',
  'Platforms' => '',
  'InstanceFamilies' => '',
  'AppBlockArn' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'Name' => '',
  'DisplayName' => '',
  'Description' => '',
  'IconS3Location' => '',
  'LaunchPath' => '',
  'WorkingDirectory' => '',
  'LaunchParameters' => '',
  'Platforms' => '',
  'InstanceFamilies' => '',
  'AppBlockArn' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateApplication');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateApplication' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "DisplayName": "",
  "Description": "",
  "IconS3Location": "",
  "LaunchPath": "",
  "WorkingDirectory": "",
  "LaunchParameters": "",
  "Platforms": "",
  "InstanceFamilies": "",
  "AppBlockArn": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateApplication' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "DisplayName": "",
  "Description": "",
  "IconS3Location": "",
  "LaunchPath": "",
  "WorkingDirectory": "",
  "LaunchParameters": "",
  "Platforms": "",
  "InstanceFamilies": "",
  "AppBlockArn": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"Platforms\": \"\",\n  \"InstanceFamilies\": \"\",\n  \"AppBlockArn\": \"\",\n  \"Tags\": \"\"\n}"

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

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

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

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

import requests

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

payload = {
    "Name": "",
    "DisplayName": "",
    "Description": "",
    "IconS3Location": "",
    "LaunchPath": "",
    "WorkingDirectory": "",
    "LaunchParameters": "",
    "Platforms": "",
    "InstanceFamilies": "",
    "AppBlockArn": "",
    "Tags": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateApplication"

payload <- "{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"Platforms\": \"\",\n  \"InstanceFamilies\": \"\",\n  \"AppBlockArn\": \"\",\n  \"Tags\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"Platforms\": \"\",\n  \"InstanceFamilies\": \"\",\n  \"AppBlockArn\": \"\",\n  \"Tags\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"Platforms\": \"\",\n  \"InstanceFamilies\": \"\",\n  \"AppBlockArn\": \"\",\n  \"Tags\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "Name": "",
        "DisplayName": "",
        "Description": "",
        "IconS3Location": "",
        "LaunchPath": "",
        "WorkingDirectory": "",
        "LaunchParameters": "",
        "Platforms": "",
        "InstanceFamilies": "",
        "AppBlockArn": "",
        "Tags": ""
    });

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

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateApplication' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": "",
  "DisplayName": "",
  "Description": "",
  "IconS3Location": "",
  "LaunchPath": "",
  "WorkingDirectory": "",
  "LaunchParameters": "",
  "Platforms": "",
  "InstanceFamilies": "",
  "AppBlockArn": "",
  "Tags": ""
}'

echo '{
  "Name": "",
  "DisplayName": "",
  "Description": "",
  "IconS3Location": "",
  "LaunchPath": "",
  "WorkingDirectory": "",
  "LaunchParameters": "",
  "Platforms": "",
  "InstanceFamilies": "",
  "AppBlockArn": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateApplication' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "DisplayName": "",\n  "Description": "",\n  "IconS3Location": "",\n  "LaunchPath": "",\n  "WorkingDirectory": "",\n  "LaunchParameters": "",\n  "Platforms": "",\n  "InstanceFamilies": "",\n  "AppBlockArn": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateApplication'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "DisplayName": "",
  "Description": "",
  "IconS3Location": "",
  "LaunchPath": "",
  "WorkingDirectory": "",
  "LaunchParameters": "",
  "Platforms": "",
  "InstanceFamilies": "",
  "AppBlockArn": "",
  "Tags": ""
] as [String : Any]

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

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateDirectoryConfig

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateDirectoryConfig

HEADERS

X-Amz-Target

BODY json

{
  "DirectoryName": "",
  "OrganizationalUnitDistinguishedNames": "",
  "ServiceAccountCredentials": "",
  "CertificateBasedAuthProperties": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"DirectoryName\": \"\",\n  \"OrganizationalUnitDistinguishedNames\": \"\",\n  \"ServiceAccountCredentials\": \"\",\n  \"CertificateBasedAuthProperties\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateDirectoryConfig" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:DirectoryName ""
                                                                                                                      :OrganizationalUnitDistinguishedNames ""
                                                                                                                      :ServiceAccountCredentials ""
                                                                                                                      :CertificateBasedAuthProperties ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateDirectoryConfig"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"DirectoryName\": \"\",\n  \"OrganizationalUnitDistinguishedNames\": \"\",\n  \"ServiceAccountCredentials\": \"\",\n  \"CertificateBasedAuthProperties\": \"\"\n}"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateDirectoryConfig"

	payload := strings.NewReader("{\n  \"DirectoryName\": \"\",\n  \"OrganizationalUnitDistinguishedNames\": \"\",\n  \"ServiceAccountCredentials\": \"\",\n  \"CertificateBasedAuthProperties\": \"\"\n}")

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

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

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

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

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

}

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

{
  "DirectoryName": "",
  "OrganizationalUnitDistinguishedNames": "",
  "ServiceAccountCredentials": "",
  "CertificateBasedAuthProperties": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateDirectoryConfig")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"DirectoryName\": \"\",\n  \"OrganizationalUnitDistinguishedNames\": \"\",\n  \"ServiceAccountCredentials\": \"\",\n  \"CertificateBasedAuthProperties\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  DirectoryName: '',
  OrganizationalUnitDistinguishedNames: '',
  ServiceAccountCredentials: '',
  CertificateBasedAuthProperties: ''
});

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=PhotonAdminProxyService.CreateDirectoryConfig');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateDirectoryConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    DirectoryName: '',
    OrganizationalUnitDistinguishedNames: '',
    ServiceAccountCredentials: '',
    CertificateBasedAuthProperties: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateDirectoryConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DirectoryName":"","OrganizationalUnitDistinguishedNames":"","ServiceAccountCredentials":"","CertificateBasedAuthProperties":""}'
};

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=PhotonAdminProxyService.CreateDirectoryConfig',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DirectoryName": "",\n  "OrganizationalUnitDistinguishedNames": "",\n  "ServiceAccountCredentials": "",\n  "CertificateBasedAuthProperties": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DirectoryName\": \"\",\n  \"OrganizationalUnitDistinguishedNames\": \"\",\n  \"ServiceAccountCredentials\": \"\",\n  \"CertificateBasedAuthProperties\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateDirectoryConfig")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  DirectoryName: '',
  OrganizationalUnitDistinguishedNames: '',
  ServiceAccountCredentials: '',
  CertificateBasedAuthProperties: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateDirectoryConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    DirectoryName: '',
    OrganizationalUnitDistinguishedNames: '',
    ServiceAccountCredentials: '',
    CertificateBasedAuthProperties: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  DirectoryName: '',
  OrganizationalUnitDistinguishedNames: '',
  ServiceAccountCredentials: '',
  CertificateBasedAuthProperties: ''
});

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=PhotonAdminProxyService.CreateDirectoryConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    DirectoryName: '',
    OrganizationalUnitDistinguishedNames: '',
    ServiceAccountCredentials: '',
    CertificateBasedAuthProperties: ''
  }
};

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=PhotonAdminProxyService.CreateDirectoryConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DirectoryName":"","OrganizationalUnitDistinguishedNames":"","ServiceAccountCredentials":"","CertificateBasedAuthProperties":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"DirectoryName": @"",
                              @"OrganizationalUnitDistinguishedNames": @"",
                              @"ServiceAccountCredentials": @"",
                              @"CertificateBasedAuthProperties": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateDirectoryConfig" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"DirectoryName\": \"\",\n  \"OrganizationalUnitDistinguishedNames\": \"\",\n  \"ServiceAccountCredentials\": \"\",\n  \"CertificateBasedAuthProperties\": \"\"\n}" in

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

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

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateDirectoryConfig', [
  'body' => '{
  "DirectoryName": "",
  "OrganizationalUnitDistinguishedNames": "",
  "ServiceAccountCredentials": "",
  "CertificateBasedAuthProperties": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DirectoryName' => '',
  'OrganizationalUnitDistinguishedNames' => '',
  'ServiceAccountCredentials' => '',
  'CertificateBasedAuthProperties' => ''
]));

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

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

append(json_encode([
  'DirectoryName' => '',
  'OrganizationalUnitDistinguishedNames' => '',
  'ServiceAccountCredentials' => '',
  'CertificateBasedAuthProperties' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateDirectoryConfig');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateDirectoryConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DirectoryName": "",
  "OrganizationalUnitDistinguishedNames": "",
  "ServiceAccountCredentials": "",
  "CertificateBasedAuthProperties": ""
}'

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

import http.client

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

payload = "{\n  \"DirectoryName\": \"\",\n  \"OrganizationalUnitDistinguishedNames\": \"\",\n  \"ServiceAccountCredentials\": \"\",\n  \"CertificateBasedAuthProperties\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateDirectoryConfig"

payload = {
    "DirectoryName": "",
    "OrganizationalUnitDistinguishedNames": "",
    "ServiceAccountCredentials": "",
    "CertificateBasedAuthProperties": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateDirectoryConfig"

payload <- "{\n  \"DirectoryName\": \"\",\n  \"OrganizationalUnitDistinguishedNames\": \"\",\n  \"ServiceAccountCredentials\": \"\",\n  \"CertificateBasedAuthProperties\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "DirectoryName": "",
        "OrganizationalUnitDistinguishedNames": "",
        "ServiceAccountCredentials": "",
        "CertificateBasedAuthProperties": ""
    });

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

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateDirectoryConfig' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "DirectoryName": "",
  "OrganizationalUnitDistinguishedNames": "",
  "ServiceAccountCredentials": "",
  "CertificateBasedAuthProperties": ""
}'

echo '{
  "DirectoryName": "",
  "OrganizationalUnitDistinguishedNames": "",
  "ServiceAccountCredentials": "",
  "CertificateBasedAuthProperties": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateDirectoryConfig' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "DirectoryName": "",\n  "OrganizationalUnitDistinguishedNames": "",\n  "ServiceAccountCredentials": "",\n  "CertificateBasedAuthProperties": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateDirectoryConfig'

import Foundation

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

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

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateEntitlement

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateEntitlement

HEADERS

X-Amz-Target

BODY json

{
  "Name": "",
  "StackName": "",
  "Description": "",
  "AppVisibility": "",
  "Attributes": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"Description\": \"\",\n  \"AppVisibility\": \"\",\n  \"Attributes\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateEntitlement" {:headers {:x-amz-target ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:Name ""
                                                                                                                  :StackName ""
                                                                                                                  :Description ""
                                                                                                                  :AppVisibility ""
                                                                                                                  :Attributes ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateEntitlement"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"Description\": \"\",\n  \"AppVisibility\": \"\",\n  \"Attributes\": \"\"\n}"

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

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

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateEntitlement");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"Description\": \"\",\n  \"AppVisibility\": \"\",\n  \"Attributes\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateEntitlement"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"Description\": \"\",\n  \"AppVisibility\": \"\",\n  \"Attributes\": \"\"\n}")

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

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

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

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

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

}

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

{
  "Name": "",
  "StackName": "",
  "Description": "",
  "AppVisibility": "",
  "Attributes": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"Description\": \"\",\n  \"AppVisibility\": \"\",\n  \"Attributes\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateEntitlement")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateEntitlement")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"Description\": \"\",\n  \"AppVisibility\": \"\",\n  \"Attributes\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  StackName: '',
  Description: '',
  AppVisibility: '',
  Attributes: ''
});

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=PhotonAdminProxyService.CreateEntitlement');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateEntitlement',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', StackName: '', Description: '', AppVisibility: '', Attributes: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateEntitlement';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","StackName":"","Description":"","AppVisibility":"","Attributes":""}'
};

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=PhotonAdminProxyService.CreateEntitlement',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "StackName": "",\n  "Description": "",\n  "AppVisibility": "",\n  "Attributes": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"Description\": \"\",\n  \"AppVisibility\": \"\",\n  \"Attributes\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateEntitlement")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({Name: '', StackName: '', Description: '', AppVisibility: '', Attributes: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateEntitlement',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: '', StackName: '', Description: '', AppVisibility: '', Attributes: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  Name: '',
  StackName: '',
  Description: '',
  AppVisibility: '',
  Attributes: ''
});

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=PhotonAdminProxyService.CreateEntitlement',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', StackName: '', Description: '', AppVisibility: '', Attributes: ''}
};

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=PhotonAdminProxyService.CreateEntitlement';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","StackName":"","Description":"","AppVisibility":"","Attributes":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"StackName": @"",
                              @"Description": @"",
                              @"AppVisibility": @"",
                              @"Attributes": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateEntitlement" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"Description\": \"\",\n  \"AppVisibility\": \"\",\n  \"Attributes\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateEntitlement",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'StackName' => '',
    'Description' => '',
    'AppVisibility' => '',
    'Attributes' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateEntitlement', [
  'body' => '{
  "Name": "",
  "StackName": "",
  "Description": "",
  "AppVisibility": "",
  "Attributes": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'StackName' => '',
  'Description' => '',
  'AppVisibility' => '',
  'Attributes' => ''
]));

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

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

append(json_encode([
  'Name' => '',
  'StackName' => '',
  'Description' => '',
  'AppVisibility' => '',
  'Attributes' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateEntitlement');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateEntitlement' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "StackName": "",
  "Description": "",
  "AppVisibility": "",
  "Attributes": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateEntitlement' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "StackName": "",
  "Description": "",
  "AppVisibility": "",
  "Attributes": ""
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"Description\": \"\",\n  \"AppVisibility\": \"\",\n  \"Attributes\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateEntitlement"

payload = {
    "Name": "",
    "StackName": "",
    "Description": "",
    "AppVisibility": "",
    "Attributes": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateEntitlement"

payload <- "{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"Description\": \"\",\n  \"AppVisibility\": \"\",\n  \"Attributes\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "Name": "",
        "StackName": "",
        "Description": "",
        "AppVisibility": "",
        "Attributes": ""
    });

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

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateEntitlement' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": "",
  "StackName": "",
  "Description": "",
  "AppVisibility": "",
  "Attributes": ""
}'

echo '{
  "Name": "",
  "StackName": "",
  "Description": "",
  "AppVisibility": "",
  "Attributes": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateEntitlement' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "StackName": "",\n  "Description": "",\n  "AppVisibility": "",\n  "Attributes": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateEntitlement'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "StackName": "",
  "Description": "",
  "AppVisibility": "",
  "Attributes": ""
] as [String : Any]

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

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateFleet

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateFleet

HEADERS

X-Amz-Target

BODY json

{
  "Name": "",
  "ImageName": "",
  "ImageArn": "",
  "InstanceType": "",
  "FleetType": "",
  "ComputeCapacity": "",
  "VpcConfig": "",
  "MaxUserDurationInSeconds": "",
  "DisconnectTimeoutInSeconds": "",
  "Description": "",
  "DisplayName": "",
  "EnableDefaultInternetAccess": "",
  "DomainJoinInfo": "",
  "Tags": "",
  "IdleDisconnectTimeoutInSeconds": "",
  "IamRoleArn": "",
  "StreamView": "",
  "Platform": "",
  "MaxConcurrentSessions": "",
  "UsbDeviceFilterStrings": "",
  "SessionScriptS3Location": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"FleetType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"Tags\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateFleet" {:headers {:x-amz-target ""}
                                                                                              :content-type :json
                                                                                              :form-params {:Name ""
                                                                                                            :ImageName ""
                                                                                                            :ImageArn ""
                                                                                                            :InstanceType ""
                                                                                                            :FleetType ""
                                                                                                            :ComputeCapacity ""
                                                                                                            :VpcConfig ""
                                                                                                            :MaxUserDurationInSeconds ""
                                                                                                            :DisconnectTimeoutInSeconds ""
                                                                                                            :Description ""
                                                                                                            :DisplayName ""
                                                                                                            :EnableDefaultInternetAccess ""
                                                                                                            :DomainJoinInfo ""
                                                                                                            :Tags ""
                                                                                                            :IdleDisconnectTimeoutInSeconds ""
                                                                                                            :IamRoleArn ""
                                                                                                            :StreamView ""
                                                                                                            :Platform ""
                                                                                                            :MaxConcurrentSessions ""
                                                                                                            :UsbDeviceFilterStrings ""
                                                                                                            :SessionScriptS3Location ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateFleet"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"FleetType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"Tags\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateFleet"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"FleetType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"Tags\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateFleet");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"FleetType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"Tags\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateFleet"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"FleetType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"Tags\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}")

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

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

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

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

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

}

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

{
  "Name": "",
  "ImageName": "",
  "ImageArn": "",
  "InstanceType": "",
  "FleetType": "",
  "ComputeCapacity": "",
  "VpcConfig": "",
  "MaxUserDurationInSeconds": "",
  "DisconnectTimeoutInSeconds": "",
  "Description": "",
  "DisplayName": "",
  "EnableDefaultInternetAccess": "",
  "DomainJoinInfo": "",
  "Tags": "",
  "IdleDisconnectTimeoutInSeconds": "",
  "IamRoleArn": "",
  "StreamView": "",
  "Platform": "",
  "MaxConcurrentSessions": "",
  "UsbDeviceFilterStrings": "",
  "SessionScriptS3Location": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateFleet")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"FleetType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"Tags\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateFleet"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"FleetType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"Tags\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"FleetType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"Tags\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateFleet")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateFleet")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"FleetType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"Tags\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  ImageName: '',
  ImageArn: '',
  InstanceType: '',
  FleetType: '',
  ComputeCapacity: '',
  VpcConfig: '',
  MaxUserDurationInSeconds: '',
  DisconnectTimeoutInSeconds: '',
  Description: '',
  DisplayName: '',
  EnableDefaultInternetAccess: '',
  DomainJoinInfo: '',
  Tags: '',
  IdleDisconnectTimeoutInSeconds: '',
  IamRoleArn: '',
  StreamView: '',
  Platform: '',
  MaxConcurrentSessions: '',
  UsbDeviceFilterStrings: '',
  SessionScriptS3Location: ''
});

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=PhotonAdminProxyService.CreateFleet');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    ImageName: '',
    ImageArn: '',
    InstanceType: '',
    FleetType: '',
    ComputeCapacity: '',
    VpcConfig: '',
    MaxUserDurationInSeconds: '',
    DisconnectTimeoutInSeconds: '',
    Description: '',
    DisplayName: '',
    EnableDefaultInternetAccess: '',
    DomainJoinInfo: '',
    Tags: '',
    IdleDisconnectTimeoutInSeconds: '',
    IamRoleArn: '',
    StreamView: '',
    Platform: '',
    MaxConcurrentSessions: '',
    UsbDeviceFilterStrings: '',
    SessionScriptS3Location: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateFleet';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","ImageName":"","ImageArn":"","InstanceType":"","FleetType":"","ComputeCapacity":"","VpcConfig":"","MaxUserDurationInSeconds":"","DisconnectTimeoutInSeconds":"","Description":"","DisplayName":"","EnableDefaultInternetAccess":"","DomainJoinInfo":"","Tags":"","IdleDisconnectTimeoutInSeconds":"","IamRoleArn":"","StreamView":"","Platform":"","MaxConcurrentSessions":"","UsbDeviceFilterStrings":"","SessionScriptS3Location":""}'
};

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=PhotonAdminProxyService.CreateFleet',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "ImageName": "",\n  "ImageArn": "",\n  "InstanceType": "",\n  "FleetType": "",\n  "ComputeCapacity": "",\n  "VpcConfig": "",\n  "MaxUserDurationInSeconds": "",\n  "DisconnectTimeoutInSeconds": "",\n  "Description": "",\n  "DisplayName": "",\n  "EnableDefaultInternetAccess": "",\n  "DomainJoinInfo": "",\n  "Tags": "",\n  "IdleDisconnectTimeoutInSeconds": "",\n  "IamRoleArn": "",\n  "StreamView": "",\n  "Platform": "",\n  "MaxConcurrentSessions": "",\n  "UsbDeviceFilterStrings": "",\n  "SessionScriptS3Location": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"FleetType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"Tags\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateFleet")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  Name: '',
  ImageName: '',
  ImageArn: '',
  InstanceType: '',
  FleetType: '',
  ComputeCapacity: '',
  VpcConfig: '',
  MaxUserDurationInSeconds: '',
  DisconnectTimeoutInSeconds: '',
  Description: '',
  DisplayName: '',
  EnableDefaultInternetAccess: '',
  DomainJoinInfo: '',
  Tags: '',
  IdleDisconnectTimeoutInSeconds: '',
  IamRoleArn: '',
  StreamView: '',
  Platform: '',
  MaxConcurrentSessions: '',
  UsbDeviceFilterStrings: '',
  SessionScriptS3Location: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    Name: '',
    ImageName: '',
    ImageArn: '',
    InstanceType: '',
    FleetType: '',
    ComputeCapacity: '',
    VpcConfig: '',
    MaxUserDurationInSeconds: '',
    DisconnectTimeoutInSeconds: '',
    Description: '',
    DisplayName: '',
    EnableDefaultInternetAccess: '',
    DomainJoinInfo: '',
    Tags: '',
    IdleDisconnectTimeoutInSeconds: '',
    IamRoleArn: '',
    StreamView: '',
    Platform: '',
    MaxConcurrentSessions: '',
    UsbDeviceFilterStrings: '',
    SessionScriptS3Location: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  Name: '',
  ImageName: '',
  ImageArn: '',
  InstanceType: '',
  FleetType: '',
  ComputeCapacity: '',
  VpcConfig: '',
  MaxUserDurationInSeconds: '',
  DisconnectTimeoutInSeconds: '',
  Description: '',
  DisplayName: '',
  EnableDefaultInternetAccess: '',
  DomainJoinInfo: '',
  Tags: '',
  IdleDisconnectTimeoutInSeconds: '',
  IamRoleArn: '',
  StreamView: '',
  Platform: '',
  MaxConcurrentSessions: '',
  UsbDeviceFilterStrings: '',
  SessionScriptS3Location: ''
});

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=PhotonAdminProxyService.CreateFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    ImageName: '',
    ImageArn: '',
    InstanceType: '',
    FleetType: '',
    ComputeCapacity: '',
    VpcConfig: '',
    MaxUserDurationInSeconds: '',
    DisconnectTimeoutInSeconds: '',
    Description: '',
    DisplayName: '',
    EnableDefaultInternetAccess: '',
    DomainJoinInfo: '',
    Tags: '',
    IdleDisconnectTimeoutInSeconds: '',
    IamRoleArn: '',
    StreamView: '',
    Platform: '',
    MaxConcurrentSessions: '',
    UsbDeviceFilterStrings: '',
    SessionScriptS3Location: ''
  }
};

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=PhotonAdminProxyService.CreateFleet';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","ImageName":"","ImageArn":"","InstanceType":"","FleetType":"","ComputeCapacity":"","VpcConfig":"","MaxUserDurationInSeconds":"","DisconnectTimeoutInSeconds":"","Description":"","DisplayName":"","EnableDefaultInternetAccess":"","DomainJoinInfo":"","Tags":"","IdleDisconnectTimeoutInSeconds":"","IamRoleArn":"","StreamView":"","Platform":"","MaxConcurrentSessions":"","UsbDeviceFilterStrings":"","SessionScriptS3Location":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"ImageName": @"",
                              @"ImageArn": @"",
                              @"InstanceType": @"",
                              @"FleetType": @"",
                              @"ComputeCapacity": @"",
                              @"VpcConfig": @"",
                              @"MaxUserDurationInSeconds": @"",
                              @"DisconnectTimeoutInSeconds": @"",
                              @"Description": @"",
                              @"DisplayName": @"",
                              @"EnableDefaultInternetAccess": @"",
                              @"DomainJoinInfo": @"",
                              @"Tags": @"",
                              @"IdleDisconnectTimeoutInSeconds": @"",
                              @"IamRoleArn": @"",
                              @"StreamView": @"",
                              @"Platform": @"",
                              @"MaxConcurrentSessions": @"",
                              @"UsbDeviceFilterStrings": @"",
                              @"SessionScriptS3Location": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateFleet" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"FleetType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"Tags\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateFleet",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'ImageName' => '',
    'ImageArn' => '',
    'InstanceType' => '',
    'FleetType' => '',
    'ComputeCapacity' => '',
    'VpcConfig' => '',
    'MaxUserDurationInSeconds' => '',
    'DisconnectTimeoutInSeconds' => '',
    'Description' => '',
    'DisplayName' => '',
    'EnableDefaultInternetAccess' => '',
    'DomainJoinInfo' => '',
    'Tags' => '',
    'IdleDisconnectTimeoutInSeconds' => '',
    'IamRoleArn' => '',
    'StreamView' => '',
    'Platform' => '',
    'MaxConcurrentSessions' => '',
    'UsbDeviceFilterStrings' => '',
    'SessionScriptS3Location' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateFleet', [
  'body' => '{
  "Name": "",
  "ImageName": "",
  "ImageArn": "",
  "InstanceType": "",
  "FleetType": "",
  "ComputeCapacity": "",
  "VpcConfig": "",
  "MaxUserDurationInSeconds": "",
  "DisconnectTimeoutInSeconds": "",
  "Description": "",
  "DisplayName": "",
  "EnableDefaultInternetAccess": "",
  "DomainJoinInfo": "",
  "Tags": "",
  "IdleDisconnectTimeoutInSeconds": "",
  "IamRoleArn": "",
  "StreamView": "",
  "Platform": "",
  "MaxConcurrentSessions": "",
  "UsbDeviceFilterStrings": "",
  "SessionScriptS3Location": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'ImageName' => '',
  'ImageArn' => '',
  'InstanceType' => '',
  'FleetType' => '',
  'ComputeCapacity' => '',
  'VpcConfig' => '',
  'MaxUserDurationInSeconds' => '',
  'DisconnectTimeoutInSeconds' => '',
  'Description' => '',
  'DisplayName' => '',
  'EnableDefaultInternetAccess' => '',
  'DomainJoinInfo' => '',
  'Tags' => '',
  'IdleDisconnectTimeoutInSeconds' => '',
  'IamRoleArn' => '',
  'StreamView' => '',
  'Platform' => '',
  'MaxConcurrentSessions' => '',
  'UsbDeviceFilterStrings' => '',
  'SessionScriptS3Location' => ''
]));

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

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

append(json_encode([
  'Name' => '',
  'ImageName' => '',
  'ImageArn' => '',
  'InstanceType' => '',
  'FleetType' => '',
  'ComputeCapacity' => '',
  'VpcConfig' => '',
  'MaxUserDurationInSeconds' => '',
  'DisconnectTimeoutInSeconds' => '',
  'Description' => '',
  'DisplayName' => '',
  'EnableDefaultInternetAccess' => '',
  'DomainJoinInfo' => '',
  'Tags' => '',
  'IdleDisconnectTimeoutInSeconds' => '',
  'IamRoleArn' => '',
  'StreamView' => '',
  'Platform' => '',
  'MaxConcurrentSessions' => '',
  'UsbDeviceFilterStrings' => '',
  'SessionScriptS3Location' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateFleet');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateFleet' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "ImageName": "",
  "ImageArn": "",
  "InstanceType": "",
  "FleetType": "",
  "ComputeCapacity": "",
  "VpcConfig": "",
  "MaxUserDurationInSeconds": "",
  "DisconnectTimeoutInSeconds": "",
  "Description": "",
  "DisplayName": "",
  "EnableDefaultInternetAccess": "",
  "DomainJoinInfo": "",
  "Tags": "",
  "IdleDisconnectTimeoutInSeconds": "",
  "IamRoleArn": "",
  "StreamView": "",
  "Platform": "",
  "MaxConcurrentSessions": "",
  "UsbDeviceFilterStrings": "",
  "SessionScriptS3Location": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateFleet' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "ImageName": "",
  "ImageArn": "",
  "InstanceType": "",
  "FleetType": "",
  "ComputeCapacity": "",
  "VpcConfig": "",
  "MaxUserDurationInSeconds": "",
  "DisconnectTimeoutInSeconds": "",
  "Description": "",
  "DisplayName": "",
  "EnableDefaultInternetAccess": "",
  "DomainJoinInfo": "",
  "Tags": "",
  "IdleDisconnectTimeoutInSeconds": "",
  "IamRoleArn": "",
  "StreamView": "",
  "Platform": "",
  "MaxConcurrentSessions": "",
  "UsbDeviceFilterStrings": "",
  "SessionScriptS3Location": ""
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"FleetType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"Tags\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateFleet"

payload = {
    "Name": "",
    "ImageName": "",
    "ImageArn": "",
    "InstanceType": "",
    "FleetType": "",
    "ComputeCapacity": "",
    "VpcConfig": "",
    "MaxUserDurationInSeconds": "",
    "DisconnectTimeoutInSeconds": "",
    "Description": "",
    "DisplayName": "",
    "EnableDefaultInternetAccess": "",
    "DomainJoinInfo": "",
    "Tags": "",
    "IdleDisconnectTimeoutInSeconds": "",
    "IamRoleArn": "",
    "StreamView": "",
    "Platform": "",
    "MaxConcurrentSessions": "",
    "UsbDeviceFilterStrings": "",
    "SessionScriptS3Location": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateFleet"

payload <- "{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"FleetType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"Tags\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"FleetType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"Tags\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"FleetType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"Tags\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "Name": "",
        "ImageName": "",
        "ImageArn": "",
        "InstanceType": "",
        "FleetType": "",
        "ComputeCapacity": "",
        "VpcConfig": "",
        "MaxUserDurationInSeconds": "",
        "DisconnectTimeoutInSeconds": "",
        "Description": "",
        "DisplayName": "",
        "EnableDefaultInternetAccess": "",
        "DomainJoinInfo": "",
        "Tags": "",
        "IdleDisconnectTimeoutInSeconds": "",
        "IamRoleArn": "",
        "StreamView": "",
        "Platform": "",
        "MaxConcurrentSessions": "",
        "UsbDeviceFilterStrings": "",
        "SessionScriptS3Location": ""
    });

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

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateFleet' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": "",
  "ImageName": "",
  "ImageArn": "",
  "InstanceType": "",
  "FleetType": "",
  "ComputeCapacity": "",
  "VpcConfig": "",
  "MaxUserDurationInSeconds": "",
  "DisconnectTimeoutInSeconds": "",
  "Description": "",
  "DisplayName": "",
  "EnableDefaultInternetAccess": "",
  "DomainJoinInfo": "",
  "Tags": "",
  "IdleDisconnectTimeoutInSeconds": "",
  "IamRoleArn": "",
  "StreamView": "",
  "Platform": "",
  "MaxConcurrentSessions": "",
  "UsbDeviceFilterStrings": "",
  "SessionScriptS3Location": ""
}'

echo '{
  "Name": "",
  "ImageName": "",
  "ImageArn": "",
  "InstanceType": "",
  "FleetType": "",
  "ComputeCapacity": "",
  "VpcConfig": "",
  "MaxUserDurationInSeconds": "",
  "DisconnectTimeoutInSeconds": "",
  "Description": "",
  "DisplayName": "",
  "EnableDefaultInternetAccess": "",
  "DomainJoinInfo": "",
  "Tags": "",
  "IdleDisconnectTimeoutInSeconds": "",
  "IamRoleArn": "",
  "StreamView": "",
  "Platform": "",
  "MaxConcurrentSessions": "",
  "UsbDeviceFilterStrings": "",
  "SessionScriptS3Location": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateFleet' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "ImageName": "",\n  "ImageArn": "",\n  "InstanceType": "",\n  "FleetType": "",\n  "ComputeCapacity": "",\n  "VpcConfig": "",\n  "MaxUserDurationInSeconds": "",\n  "DisconnectTimeoutInSeconds": "",\n  "Description": "",\n  "DisplayName": "",\n  "EnableDefaultInternetAccess": "",\n  "DomainJoinInfo": "",\n  "Tags": "",\n  "IdleDisconnectTimeoutInSeconds": "",\n  "IamRoleArn": "",\n  "StreamView": "",\n  "Platform": "",\n  "MaxConcurrentSessions": "",\n  "UsbDeviceFilterStrings": "",\n  "SessionScriptS3Location": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateFleet'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "ImageName": "",
  "ImageArn": "",
  "InstanceType": "",
  "FleetType": "",
  "ComputeCapacity": "",
  "VpcConfig": "",
  "MaxUserDurationInSeconds": "",
  "DisconnectTimeoutInSeconds": "",
  "Description": "",
  "DisplayName": "",
  "EnableDefaultInternetAccess": "",
  "DomainJoinInfo": "",
  "Tags": "",
  "IdleDisconnectTimeoutInSeconds": "",
  "IamRoleArn": "",
  "StreamView": "",
  "Platform": "",
  "MaxConcurrentSessions": "",
  "UsbDeviceFilterStrings": "",
  "SessionScriptS3Location": ""
] as [String : Any]

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

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateImageBuilder

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilder

HEADERS

X-Amz-Target

BODY json

{
  "Name": "",
  "ImageName": "",
  "ImageArn": "",
  "InstanceType": "",
  "Description": "",
  "DisplayName": "",
  "VpcConfig": "",
  "IamRoleArn": "",
  "EnableDefaultInternetAccess": "",
  "DomainJoinInfo": "",
  "AppstreamAgentVersion": "",
  "Tags": "",
  "AccessEndpoints": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"VpcConfig\": \"\",\n  \"IamRoleArn\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"AppstreamAgentVersion\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilder" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:Name ""
                                                                                                                   :ImageName ""
                                                                                                                   :ImageArn ""
                                                                                                                   :InstanceType ""
                                                                                                                   :Description ""
                                                                                                                   :DisplayName ""
                                                                                                                   :VpcConfig ""
                                                                                                                   :IamRoleArn ""
                                                                                                                   :EnableDefaultInternetAccess ""
                                                                                                                   :DomainJoinInfo ""
                                                                                                                   :AppstreamAgentVersion ""
                                                                                                                   :Tags ""
                                                                                                                   :AccessEndpoints ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilder"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"VpcConfig\": \"\",\n  \"IamRoleArn\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"AppstreamAgentVersion\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilder"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"VpcConfig\": \"\",\n  \"IamRoleArn\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"AppstreamAgentVersion\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilder");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"VpcConfig\": \"\",\n  \"IamRoleArn\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"AppstreamAgentVersion\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilder"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"VpcConfig\": \"\",\n  \"IamRoleArn\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"AppstreamAgentVersion\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\"\n}")

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

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

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

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

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

}

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

{
  "Name": "",
  "ImageName": "",
  "ImageArn": "",
  "InstanceType": "",
  "Description": "",
  "DisplayName": "",
  "VpcConfig": "",
  "IamRoleArn": "",
  "EnableDefaultInternetAccess": "",
  "DomainJoinInfo": "",
  "AppstreamAgentVersion": "",
  "Tags": "",
  "AccessEndpoints": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilder")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"VpcConfig\": \"\",\n  \"IamRoleArn\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"AppstreamAgentVersion\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilder"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"VpcConfig\": \"\",\n  \"IamRoleArn\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"AppstreamAgentVersion\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"VpcConfig\": \"\",\n  \"IamRoleArn\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"AppstreamAgentVersion\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilder")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilder")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"VpcConfig\": \"\",\n  \"IamRoleArn\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"AppstreamAgentVersion\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  ImageName: '',
  ImageArn: '',
  InstanceType: '',
  Description: '',
  DisplayName: '',
  VpcConfig: '',
  IamRoleArn: '',
  EnableDefaultInternetAccess: '',
  DomainJoinInfo: '',
  AppstreamAgentVersion: '',
  Tags: '',
  AccessEndpoints: ''
});

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=PhotonAdminProxyService.CreateImageBuilder');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilder',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    ImageName: '',
    ImageArn: '',
    InstanceType: '',
    Description: '',
    DisplayName: '',
    VpcConfig: '',
    IamRoleArn: '',
    EnableDefaultInternetAccess: '',
    DomainJoinInfo: '',
    AppstreamAgentVersion: '',
    Tags: '',
    AccessEndpoints: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilder';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","ImageName":"","ImageArn":"","InstanceType":"","Description":"","DisplayName":"","VpcConfig":"","IamRoleArn":"","EnableDefaultInternetAccess":"","DomainJoinInfo":"","AppstreamAgentVersion":"","Tags":"","AccessEndpoints":""}'
};

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=PhotonAdminProxyService.CreateImageBuilder',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "ImageName": "",\n  "ImageArn": "",\n  "InstanceType": "",\n  "Description": "",\n  "DisplayName": "",\n  "VpcConfig": "",\n  "IamRoleArn": "",\n  "EnableDefaultInternetAccess": "",\n  "DomainJoinInfo": "",\n  "AppstreamAgentVersion": "",\n  "Tags": "",\n  "AccessEndpoints": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"VpcConfig\": \"\",\n  \"IamRoleArn\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"AppstreamAgentVersion\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilder")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  Name: '',
  ImageName: '',
  ImageArn: '',
  InstanceType: '',
  Description: '',
  DisplayName: '',
  VpcConfig: '',
  IamRoleArn: '',
  EnableDefaultInternetAccess: '',
  DomainJoinInfo: '',
  AppstreamAgentVersion: '',
  Tags: '',
  AccessEndpoints: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilder',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    Name: '',
    ImageName: '',
    ImageArn: '',
    InstanceType: '',
    Description: '',
    DisplayName: '',
    VpcConfig: '',
    IamRoleArn: '',
    EnableDefaultInternetAccess: '',
    DomainJoinInfo: '',
    AppstreamAgentVersion: '',
    Tags: '',
    AccessEndpoints: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  Name: '',
  ImageName: '',
  ImageArn: '',
  InstanceType: '',
  Description: '',
  DisplayName: '',
  VpcConfig: '',
  IamRoleArn: '',
  EnableDefaultInternetAccess: '',
  DomainJoinInfo: '',
  AppstreamAgentVersion: '',
  Tags: '',
  AccessEndpoints: ''
});

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=PhotonAdminProxyService.CreateImageBuilder',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    ImageName: '',
    ImageArn: '',
    InstanceType: '',
    Description: '',
    DisplayName: '',
    VpcConfig: '',
    IamRoleArn: '',
    EnableDefaultInternetAccess: '',
    DomainJoinInfo: '',
    AppstreamAgentVersion: '',
    Tags: '',
    AccessEndpoints: ''
  }
};

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=PhotonAdminProxyService.CreateImageBuilder';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","ImageName":"","ImageArn":"","InstanceType":"","Description":"","DisplayName":"","VpcConfig":"","IamRoleArn":"","EnableDefaultInternetAccess":"","DomainJoinInfo":"","AppstreamAgentVersion":"","Tags":"","AccessEndpoints":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"ImageName": @"",
                              @"ImageArn": @"",
                              @"InstanceType": @"",
                              @"Description": @"",
                              @"DisplayName": @"",
                              @"VpcConfig": @"",
                              @"IamRoleArn": @"",
                              @"EnableDefaultInternetAccess": @"",
                              @"DomainJoinInfo": @"",
                              @"AppstreamAgentVersion": @"",
                              @"Tags": @"",
                              @"AccessEndpoints": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilder" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"VpcConfig\": \"\",\n  \"IamRoleArn\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"AppstreamAgentVersion\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilder",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'ImageName' => '',
    'ImageArn' => '',
    'InstanceType' => '',
    'Description' => '',
    'DisplayName' => '',
    'VpcConfig' => '',
    'IamRoleArn' => '',
    'EnableDefaultInternetAccess' => '',
    'DomainJoinInfo' => '',
    'AppstreamAgentVersion' => '',
    'Tags' => '',
    'AccessEndpoints' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilder', [
  'body' => '{
  "Name": "",
  "ImageName": "",
  "ImageArn": "",
  "InstanceType": "",
  "Description": "",
  "DisplayName": "",
  "VpcConfig": "",
  "IamRoleArn": "",
  "EnableDefaultInternetAccess": "",
  "DomainJoinInfo": "",
  "AppstreamAgentVersion": "",
  "Tags": "",
  "AccessEndpoints": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'ImageName' => '',
  'ImageArn' => '',
  'InstanceType' => '',
  'Description' => '',
  'DisplayName' => '',
  'VpcConfig' => '',
  'IamRoleArn' => '',
  'EnableDefaultInternetAccess' => '',
  'DomainJoinInfo' => '',
  'AppstreamAgentVersion' => '',
  'Tags' => '',
  'AccessEndpoints' => ''
]));

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

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

append(json_encode([
  'Name' => '',
  'ImageName' => '',
  'ImageArn' => '',
  'InstanceType' => '',
  'Description' => '',
  'DisplayName' => '',
  'VpcConfig' => '',
  'IamRoleArn' => '',
  'EnableDefaultInternetAccess' => '',
  'DomainJoinInfo' => '',
  'AppstreamAgentVersion' => '',
  'Tags' => '',
  'AccessEndpoints' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilder');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilder' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "ImageName": "",
  "ImageArn": "",
  "InstanceType": "",
  "Description": "",
  "DisplayName": "",
  "VpcConfig": "",
  "IamRoleArn": "",
  "EnableDefaultInternetAccess": "",
  "DomainJoinInfo": "",
  "AppstreamAgentVersion": "",
  "Tags": "",
  "AccessEndpoints": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilder' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "ImageName": "",
  "ImageArn": "",
  "InstanceType": "",
  "Description": "",
  "DisplayName": "",
  "VpcConfig": "",
  "IamRoleArn": "",
  "EnableDefaultInternetAccess": "",
  "DomainJoinInfo": "",
  "AppstreamAgentVersion": "",
  "Tags": "",
  "AccessEndpoints": ""
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"VpcConfig\": \"\",\n  \"IamRoleArn\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"AppstreamAgentVersion\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilder"

payload = {
    "Name": "",
    "ImageName": "",
    "ImageArn": "",
    "InstanceType": "",
    "Description": "",
    "DisplayName": "",
    "VpcConfig": "",
    "IamRoleArn": "",
    "EnableDefaultInternetAccess": "",
    "DomainJoinInfo": "",
    "AppstreamAgentVersion": "",
    "Tags": "",
    "AccessEndpoints": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilder"

payload <- "{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"VpcConfig\": \"\",\n  \"IamRoleArn\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"AppstreamAgentVersion\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"VpcConfig\": \"\",\n  \"IamRoleArn\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"AppstreamAgentVersion\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\",\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"InstanceType\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"VpcConfig\": \"\",\n  \"IamRoleArn\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"AppstreamAgentVersion\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "Name": "",
        "ImageName": "",
        "ImageArn": "",
        "InstanceType": "",
        "Description": "",
        "DisplayName": "",
        "VpcConfig": "",
        "IamRoleArn": "",
        "EnableDefaultInternetAccess": "",
        "DomainJoinInfo": "",
        "AppstreamAgentVersion": "",
        "Tags": "",
        "AccessEndpoints": ""
    });

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

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilder' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": "",
  "ImageName": "",
  "ImageArn": "",
  "InstanceType": "",
  "Description": "",
  "DisplayName": "",
  "VpcConfig": "",
  "IamRoleArn": "",
  "EnableDefaultInternetAccess": "",
  "DomainJoinInfo": "",
  "AppstreamAgentVersion": "",
  "Tags": "",
  "AccessEndpoints": ""
}'

echo '{
  "Name": "",
  "ImageName": "",
  "ImageArn": "",
  "InstanceType": "",
  "Description": "",
  "DisplayName": "",
  "VpcConfig": "",
  "IamRoleArn": "",
  "EnableDefaultInternetAccess": "",
  "DomainJoinInfo": "",
  "AppstreamAgentVersion": "",
  "Tags": "",
  "AccessEndpoints": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilder' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "ImageName": "",\n  "ImageArn": "",\n  "InstanceType": "",\n  "Description": "",\n  "DisplayName": "",\n  "VpcConfig": "",\n  "IamRoleArn": "",\n  "EnableDefaultInternetAccess": "",\n  "DomainJoinInfo": "",\n  "AppstreamAgentVersion": "",\n  "Tags": "",\n  "AccessEndpoints": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilder'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "ImageName": "",
  "ImageArn": "",
  "InstanceType": "",
  "Description": "",
  "DisplayName": "",
  "VpcConfig": "",
  "IamRoleArn": "",
  "EnableDefaultInternetAccess": "",
  "DomainJoinInfo": "",
  "AppstreamAgentVersion": "",
  "Tags": "",
  "AccessEndpoints": ""
] as [String : Any]

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

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateImageBuilderStreamingURL

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilderStreamingURL

HEADERS

X-Amz-Target

BODY json

{
  "Name": "",
  "Validity": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"Validity\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilderStreamingURL" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:Name ""
                                                                                                                               :Validity ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilderStreamingURL"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Validity\": \"\"\n}"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilderStreamingURL"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Validity\": \"\"\n}")

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

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

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

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

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

}

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

{
  "Name": "",
  "Validity": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

const data = JSON.stringify({
  Name: '',
  Validity: ''
});

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=PhotonAdminProxyService.CreateImageBuilderStreamingURL');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilderStreamingURL',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', Validity: ''}
};

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({Name: '', Validity: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilderStreamingURL',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: '', Validity: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilderStreamingURL');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: '',
  Validity: ''
});

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=PhotonAdminProxyService.CreateImageBuilderStreamingURL',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', Validity: ''}
};

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=PhotonAdminProxyService.CreateImageBuilderStreamingURL';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","Validity":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"Validity": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilderStreamingURL"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilderStreamingURL" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"Validity\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilderStreamingURL",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'Validity' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilderStreamingURL', [
  'body' => '{
  "Name": "",
  "Validity": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilderStreamingURL');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Validity' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => '',
  'Validity' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilderStreamingURL');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilderStreamingURL' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Validity": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilderStreamingURL' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Validity": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\",\n  \"Validity\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilderStreamingURL"

payload = {
    "Name": "",
    "Validity": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilderStreamingURL"

payload <- "{\n  \"Name\": \"\",\n  \"Validity\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilderStreamingURL")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"Validity\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\",\n  \"Validity\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilderStreamingURL";

    let payload = json!({
        "Name": "",
        "Validity": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilderStreamingURL' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": "",
  "Validity": ""
}'

echo '{
  "Name": "",
  "Validity": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilderStreamingURL' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Validity": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilderStreamingURL'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "Validity": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateImageBuilderStreamingURL")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateStack

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack

HEADERS

X-Amz-Target

BODY json

{
  "Name": "",
  "Description": "",
  "DisplayName": "",
  "StorageConnectors": "",
  "RedirectURL": "",
  "FeedbackURL": "",
  "UserSettings": "",
  "ApplicationSettings": "",
  "Tags": "",
  "AccessEndpoints": "",
  "EmbedHostDomains": "",
  "StreamingExperienceSettings": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"StorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack" {:headers {:x-amz-target ""}
                                                                                              :content-type :json
                                                                                              :form-params {:Name ""
                                                                                                            :Description ""
                                                                                                            :DisplayName ""
                                                                                                            :StorageConnectors ""
                                                                                                            :RedirectURL ""
                                                                                                            :FeedbackURL ""
                                                                                                            :UserSettings ""
                                                                                                            :ApplicationSettings ""
                                                                                                            :Tags ""
                                                                                                            :AccessEndpoints ""
                                                                                                            :EmbedHostDomains ""
                                                                                                            :StreamingExperienceSettings ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"StorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"StorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"StorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"StorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 280

{
  "Name": "",
  "Description": "",
  "DisplayName": "",
  "StorageConnectors": "",
  "RedirectURL": "",
  "FeedbackURL": "",
  "UserSettings": "",
  "ApplicationSettings": "",
  "Tags": "",
  "AccessEndpoints": "",
  "EmbedHostDomains": "",
  "StreamingExperienceSettings": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"StorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"StorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"StorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"StorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Description: '',
  DisplayName: '',
  StorageConnectors: '',
  RedirectURL: '',
  FeedbackURL: '',
  UserSettings: '',
  ApplicationSettings: '',
  Tags: '',
  AccessEndpoints: '',
  EmbedHostDomains: '',
  StreamingExperienceSettings: ''
});

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=PhotonAdminProxyService.CreateStack');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    DisplayName: '',
    StorageConnectors: '',
    RedirectURL: '',
    FeedbackURL: '',
    UserSettings: '',
    ApplicationSettings: '',
    Tags: '',
    AccessEndpoints: '',
    EmbedHostDomains: '',
    StreamingExperienceSettings: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","Description":"","DisplayName":"","StorageConnectors":"","RedirectURL":"","FeedbackURL":"","UserSettings":"","ApplicationSettings":"","Tags":"","AccessEndpoints":"","EmbedHostDomains":"","StreamingExperienceSettings":""}'
};

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=PhotonAdminProxyService.CreateStack',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Description": "",\n  "DisplayName": "",\n  "StorageConnectors": "",\n  "RedirectURL": "",\n  "FeedbackURL": "",\n  "UserSettings": "",\n  "ApplicationSettings": "",\n  "Tags": "",\n  "AccessEndpoints": "",\n  "EmbedHostDomains": "",\n  "StreamingExperienceSettings": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"StorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  Name: '',
  Description: '',
  DisplayName: '',
  StorageConnectors: '',
  RedirectURL: '',
  FeedbackURL: '',
  UserSettings: '',
  ApplicationSettings: '',
  Tags: '',
  AccessEndpoints: '',
  EmbedHostDomains: '',
  StreamingExperienceSettings: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    Name: '',
    Description: '',
    DisplayName: '',
    StorageConnectors: '',
    RedirectURL: '',
    FeedbackURL: '',
    UserSettings: '',
    ApplicationSettings: '',
    Tags: '',
    AccessEndpoints: '',
    EmbedHostDomains: '',
    StreamingExperienceSettings: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: '',
  Description: '',
  DisplayName: '',
  StorageConnectors: '',
  RedirectURL: '',
  FeedbackURL: '',
  UserSettings: '',
  ApplicationSettings: '',
  Tags: '',
  AccessEndpoints: '',
  EmbedHostDomains: '',
  StreamingExperienceSettings: ''
});

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=PhotonAdminProxyService.CreateStack',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    DisplayName: '',
    StorageConnectors: '',
    RedirectURL: '',
    FeedbackURL: '',
    UserSettings: '',
    ApplicationSettings: '',
    Tags: '',
    AccessEndpoints: '',
    EmbedHostDomains: '',
    StreamingExperienceSettings: ''
  }
};

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=PhotonAdminProxyService.CreateStack';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","Description":"","DisplayName":"","StorageConnectors":"","RedirectURL":"","FeedbackURL":"","UserSettings":"","ApplicationSettings":"","Tags":"","AccessEndpoints":"","EmbedHostDomains":"","StreamingExperienceSettings":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"Description": @"",
                              @"DisplayName": @"",
                              @"StorageConnectors": @"",
                              @"RedirectURL": @"",
                              @"FeedbackURL": @"",
                              @"UserSettings": @"",
                              @"ApplicationSettings": @"",
                              @"Tags": @"",
                              @"AccessEndpoints": @"",
                              @"EmbedHostDomains": @"",
                              @"StreamingExperienceSettings": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"StorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'Description' => '',
    'DisplayName' => '',
    'StorageConnectors' => '',
    'RedirectURL' => '',
    'FeedbackURL' => '',
    'UserSettings' => '',
    'ApplicationSettings' => '',
    'Tags' => '',
    'AccessEndpoints' => '',
    'EmbedHostDomains' => '',
    'StreamingExperienceSettings' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack', [
  'body' => '{
  "Name": "",
  "Description": "",
  "DisplayName": "",
  "StorageConnectors": "",
  "RedirectURL": "",
  "FeedbackURL": "",
  "UserSettings": "",
  "ApplicationSettings": "",
  "Tags": "",
  "AccessEndpoints": "",
  "EmbedHostDomains": "",
  "StreamingExperienceSettings": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Description' => '',
  'DisplayName' => '',
  'StorageConnectors' => '',
  'RedirectURL' => '',
  'FeedbackURL' => '',
  'UserSettings' => '',
  'ApplicationSettings' => '',
  'Tags' => '',
  'AccessEndpoints' => '',
  'EmbedHostDomains' => '',
  'StreamingExperienceSettings' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => '',
  'Description' => '',
  'DisplayName' => '',
  'StorageConnectors' => '',
  'RedirectURL' => '',
  'FeedbackURL' => '',
  'UserSettings' => '',
  'ApplicationSettings' => '',
  'Tags' => '',
  'AccessEndpoints' => '',
  'EmbedHostDomains' => '',
  'StreamingExperienceSettings' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "DisplayName": "",
  "StorageConnectors": "",
  "RedirectURL": "",
  "FeedbackURL": "",
  "UserSettings": "",
  "ApplicationSettings": "",
  "Tags": "",
  "AccessEndpoints": "",
  "EmbedHostDomains": "",
  "StreamingExperienceSettings": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "DisplayName": "",
  "StorageConnectors": "",
  "RedirectURL": "",
  "FeedbackURL": "",
  "UserSettings": "",
  "ApplicationSettings": "",
  "Tags": "",
  "AccessEndpoints": "",
  "EmbedHostDomains": "",
  "StreamingExperienceSettings": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"StorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack"

payload = {
    "Name": "",
    "Description": "",
    "DisplayName": "",
    "StorageConnectors": "",
    "RedirectURL": "",
    "FeedbackURL": "",
    "UserSettings": "",
    "ApplicationSettings": "",
    "Tags": "",
    "AccessEndpoints": "",
    "EmbedHostDomains": "",
    "StreamingExperienceSettings": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack"

payload <- "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"StorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"StorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"StorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"Tags\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack";

    let payload = json!({
        "Name": "",
        "Description": "",
        "DisplayName": "",
        "StorageConnectors": "",
        "RedirectURL": "",
        "FeedbackURL": "",
        "UserSettings": "",
        "ApplicationSettings": "",
        "Tags": "",
        "AccessEndpoints": "",
        "EmbedHostDomains": "",
        "StreamingExperienceSettings": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": "",
  "Description": "",
  "DisplayName": "",
  "StorageConnectors": "",
  "RedirectURL": "",
  "FeedbackURL": "",
  "UserSettings": "",
  "ApplicationSettings": "",
  "Tags": "",
  "AccessEndpoints": "",
  "EmbedHostDomains": "",
  "StreamingExperienceSettings": ""
}'

echo '{
  "Name": "",
  "Description": "",
  "DisplayName": "",
  "StorageConnectors": "",
  "RedirectURL": "",
  "FeedbackURL": "",
  "UserSettings": "",
  "ApplicationSettings": "",
  "Tags": "",
  "AccessEndpoints": "",
  "EmbedHostDomains": "",
  "StreamingExperienceSettings": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Description": "",\n  "DisplayName": "",\n  "StorageConnectors": "",\n  "RedirectURL": "",\n  "FeedbackURL": "",\n  "UserSettings": "",\n  "ApplicationSettings": "",\n  "Tags": "",\n  "AccessEndpoints": "",\n  "EmbedHostDomains": "",\n  "StreamingExperienceSettings": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "Description": "",
  "DisplayName": "",
  "StorageConnectors": "",
  "RedirectURL": "",
  "FeedbackURL": "",
  "UserSettings": "",
  "ApplicationSettings": "",
  "Tags": "",
  "AccessEndpoints": "",
  "EmbedHostDomains": "",
  "StreamingExperienceSettings": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStack")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateStreamingURL

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL

HEADERS

X-Amz-Target

BODY json

{
  "StackName": "",
  "FleetName": "",
  "UserId": "",
  "ApplicationId": "",
  "Validity": "",
  "SessionContext": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"ApplicationId\": \"\",\n  \"Validity\": \"\",\n  \"SessionContext\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:StackName ""
                                                                                                                   :FleetName ""
                                                                                                                   :UserId ""
                                                                                                                   :ApplicationId ""
                                                                                                                   :Validity ""
                                                                                                                   :SessionContext ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"ApplicationId\": \"\",\n  \"Validity\": \"\",\n  \"SessionContext\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"ApplicationId\": \"\",\n  \"Validity\": \"\",\n  \"SessionContext\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"ApplicationId\": \"\",\n  \"Validity\": \"\",\n  \"SessionContext\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL"

	payload := strings.NewReader("{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"ApplicationId\": \"\",\n  \"Validity\": \"\",\n  \"SessionContext\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 121

{
  "StackName": "",
  "FleetName": "",
  "UserId": "",
  "ApplicationId": "",
  "Validity": "",
  "SessionContext": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"ApplicationId\": \"\",\n  \"Validity\": \"\",\n  \"SessionContext\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"ApplicationId\": \"\",\n  \"Validity\": \"\",\n  \"SessionContext\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"ApplicationId\": \"\",\n  \"Validity\": \"\",\n  \"SessionContext\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"ApplicationId\": \"\",\n  \"Validity\": \"\",\n  \"SessionContext\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  StackName: '',
  FleetName: '',
  UserId: '',
  ApplicationId: '',
  Validity: '',
  SessionContext: ''
});

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=PhotonAdminProxyService.CreateStreamingURL');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    StackName: '',
    FleetName: '',
    UserId: '',
    ApplicationId: '',
    Validity: '',
    SessionContext: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"StackName":"","FleetName":"","UserId":"","ApplicationId":"","Validity":"","SessionContext":""}'
};

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=PhotonAdminProxyService.CreateStreamingURL',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "StackName": "",\n  "FleetName": "",\n  "UserId": "",\n  "ApplicationId": "",\n  "Validity": "",\n  "SessionContext": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"ApplicationId\": \"\",\n  \"Validity\": \"\",\n  \"SessionContext\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  StackName: '',
  FleetName: '',
  UserId: '',
  ApplicationId: '',
  Validity: '',
  SessionContext: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    StackName: '',
    FleetName: '',
    UserId: '',
    ApplicationId: '',
    Validity: '',
    SessionContext: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  StackName: '',
  FleetName: '',
  UserId: '',
  ApplicationId: '',
  Validity: '',
  SessionContext: ''
});

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=PhotonAdminProxyService.CreateStreamingURL',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    StackName: '',
    FleetName: '',
    UserId: '',
    ApplicationId: '',
    Validity: '',
    SessionContext: ''
  }
};

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=PhotonAdminProxyService.CreateStreamingURL';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"StackName":"","FleetName":"","UserId":"","ApplicationId":"","Validity":"","SessionContext":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"StackName": @"",
                              @"FleetName": @"",
                              @"UserId": @"",
                              @"ApplicationId": @"",
                              @"Validity": @"",
                              @"SessionContext": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"ApplicationId\": \"\",\n  \"Validity\": \"\",\n  \"SessionContext\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'StackName' => '',
    'FleetName' => '',
    'UserId' => '',
    'ApplicationId' => '',
    'Validity' => '',
    'SessionContext' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL', [
  'body' => '{
  "StackName": "",
  "FleetName": "",
  "UserId": "",
  "ApplicationId": "",
  "Validity": "",
  "SessionContext": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'StackName' => '',
  'FleetName' => '',
  'UserId' => '',
  'ApplicationId' => '',
  'Validity' => '',
  'SessionContext' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'StackName' => '',
  'FleetName' => '',
  'UserId' => '',
  'ApplicationId' => '',
  'Validity' => '',
  'SessionContext' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "StackName": "",
  "FleetName": "",
  "UserId": "",
  "ApplicationId": "",
  "Validity": "",
  "SessionContext": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "StackName": "",
  "FleetName": "",
  "UserId": "",
  "ApplicationId": "",
  "Validity": "",
  "SessionContext": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"ApplicationId\": \"\",\n  \"Validity\": \"\",\n  \"SessionContext\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL"

payload = {
    "StackName": "",
    "FleetName": "",
    "UserId": "",
    "ApplicationId": "",
    "Validity": "",
    "SessionContext": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL"

payload <- "{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"ApplicationId\": \"\",\n  \"Validity\": \"\",\n  \"SessionContext\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"ApplicationId\": \"\",\n  \"Validity\": \"\",\n  \"SessionContext\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"ApplicationId\": \"\",\n  \"Validity\": \"\",\n  \"SessionContext\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL";

    let payload = json!({
        "StackName": "",
        "FleetName": "",
        "UserId": "",
        "ApplicationId": "",
        "Validity": "",
        "SessionContext": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "StackName": "",
  "FleetName": "",
  "UserId": "",
  "ApplicationId": "",
  "Validity": "",
  "SessionContext": ""
}'

echo '{
  "StackName": "",
  "FleetName": "",
  "UserId": "",
  "ApplicationId": "",
  "Validity": "",
  "SessionContext": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "StackName": "",\n  "FleetName": "",\n  "UserId": "",\n  "ApplicationId": "",\n  "Validity": "",\n  "SessionContext": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "StackName": "",
  "FleetName": "",
  "UserId": "",
  "ApplicationId": "",
  "Validity": "",
  "SessionContext": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateStreamingURL")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateUpdatedImage

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage

HEADERS

X-Amz-Target

BODY json

{
  "existingImageName": "",
  "newImageName": "",
  "newImageDescription": "",
  "newImageDisplayName": "",
  "newImageTags": "",
  "dryRun": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"existingImageName\": \"\",\n  \"newImageName\": \"\",\n  \"newImageDescription\": \"\",\n  \"newImageDisplayName\": \"\",\n  \"newImageTags\": \"\",\n  \"dryRun\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:existingImageName ""
                                                                                                                   :newImageName ""
                                                                                                                   :newImageDescription ""
                                                                                                                   :newImageDisplayName ""
                                                                                                                   :newImageTags ""
                                                                                                                   :dryRun ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"existingImageName\": \"\",\n  \"newImageName\": \"\",\n  \"newImageDescription\": \"\",\n  \"newImageDisplayName\": \"\",\n  \"newImageTags\": \"\",\n  \"dryRun\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"existingImageName\": \"\",\n  \"newImageName\": \"\",\n  \"newImageDescription\": \"\",\n  \"newImageDisplayName\": \"\",\n  \"newImageTags\": \"\",\n  \"dryRun\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"existingImageName\": \"\",\n  \"newImageName\": \"\",\n  \"newImageDescription\": \"\",\n  \"newImageDisplayName\": \"\",\n  \"newImageTags\": \"\",\n  \"dryRun\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage"

	payload := strings.NewReader("{\n  \"existingImageName\": \"\",\n  \"newImageName\": \"\",\n  \"newImageDescription\": \"\",\n  \"newImageDisplayName\": \"\",\n  \"newImageTags\": \"\",\n  \"dryRun\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 147

{
  "existingImageName": "",
  "newImageName": "",
  "newImageDescription": "",
  "newImageDisplayName": "",
  "newImageTags": "",
  "dryRun": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"existingImageName\": \"\",\n  \"newImageName\": \"\",\n  \"newImageDescription\": \"\",\n  \"newImageDisplayName\": \"\",\n  \"newImageTags\": \"\",\n  \"dryRun\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"existingImageName\": \"\",\n  \"newImageName\": \"\",\n  \"newImageDescription\": \"\",\n  \"newImageDisplayName\": \"\",\n  \"newImageTags\": \"\",\n  \"dryRun\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"existingImageName\": \"\",\n  \"newImageName\": \"\",\n  \"newImageDescription\": \"\",\n  \"newImageDisplayName\": \"\",\n  \"newImageTags\": \"\",\n  \"dryRun\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"existingImageName\": \"\",\n  \"newImageName\": \"\",\n  \"newImageDescription\": \"\",\n  \"newImageDisplayName\": \"\",\n  \"newImageTags\": \"\",\n  \"dryRun\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  existingImageName: '',
  newImageName: '',
  newImageDescription: '',
  newImageDisplayName: '',
  newImageTags: '',
  dryRun: ''
});

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=PhotonAdminProxyService.CreateUpdatedImage');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    existingImageName: '',
    newImageName: '',
    newImageDescription: '',
    newImageDisplayName: '',
    newImageTags: '',
    dryRun: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"existingImageName":"","newImageName":"","newImageDescription":"","newImageDisplayName":"","newImageTags":"","dryRun":""}'
};

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=PhotonAdminProxyService.CreateUpdatedImage',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "existingImageName": "",\n  "newImageName": "",\n  "newImageDescription": "",\n  "newImageDisplayName": "",\n  "newImageTags": "",\n  "dryRun": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"existingImageName\": \"\",\n  \"newImageName\": \"\",\n  \"newImageDescription\": \"\",\n  \"newImageDisplayName\": \"\",\n  \"newImageTags\": \"\",\n  \"dryRun\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  existingImageName: '',
  newImageName: '',
  newImageDescription: '',
  newImageDisplayName: '',
  newImageTags: '',
  dryRun: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    existingImageName: '',
    newImageName: '',
    newImageDescription: '',
    newImageDisplayName: '',
    newImageTags: '',
    dryRun: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  existingImageName: '',
  newImageName: '',
  newImageDescription: '',
  newImageDisplayName: '',
  newImageTags: '',
  dryRun: ''
});

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=PhotonAdminProxyService.CreateUpdatedImage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    existingImageName: '',
    newImageName: '',
    newImageDescription: '',
    newImageDisplayName: '',
    newImageTags: '',
    dryRun: ''
  }
};

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=PhotonAdminProxyService.CreateUpdatedImage';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"existingImageName":"","newImageName":"","newImageDescription":"","newImageDisplayName":"","newImageTags":"","dryRun":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"existingImageName": @"",
                              @"newImageName": @"",
                              @"newImageDescription": @"",
                              @"newImageDisplayName": @"",
                              @"newImageTags": @"",
                              @"dryRun": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"existingImageName\": \"\",\n  \"newImageName\": \"\",\n  \"newImageDescription\": \"\",\n  \"newImageDisplayName\": \"\",\n  \"newImageTags\": \"\",\n  \"dryRun\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'existingImageName' => '',
    'newImageName' => '',
    'newImageDescription' => '',
    'newImageDisplayName' => '',
    'newImageTags' => '',
    'dryRun' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage', [
  'body' => '{
  "existingImageName": "",
  "newImageName": "",
  "newImageDescription": "",
  "newImageDisplayName": "",
  "newImageTags": "",
  "dryRun": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'existingImageName' => '',
  'newImageName' => '',
  'newImageDescription' => '',
  'newImageDisplayName' => '',
  'newImageTags' => '',
  'dryRun' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'existingImageName' => '',
  'newImageName' => '',
  'newImageDescription' => '',
  'newImageDisplayName' => '',
  'newImageTags' => '',
  'dryRun' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "existingImageName": "",
  "newImageName": "",
  "newImageDescription": "",
  "newImageDisplayName": "",
  "newImageTags": "",
  "dryRun": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "existingImageName": "",
  "newImageName": "",
  "newImageDescription": "",
  "newImageDisplayName": "",
  "newImageTags": "",
  "dryRun": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"existingImageName\": \"\",\n  \"newImageName\": \"\",\n  \"newImageDescription\": \"\",\n  \"newImageDisplayName\": \"\",\n  \"newImageTags\": \"\",\n  \"dryRun\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage"

payload = {
    "existingImageName": "",
    "newImageName": "",
    "newImageDescription": "",
    "newImageDisplayName": "",
    "newImageTags": "",
    "dryRun": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage"

payload <- "{\n  \"existingImageName\": \"\",\n  \"newImageName\": \"\",\n  \"newImageDescription\": \"\",\n  \"newImageDisplayName\": \"\",\n  \"newImageTags\": \"\",\n  \"dryRun\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"existingImageName\": \"\",\n  \"newImageName\": \"\",\n  \"newImageDescription\": \"\",\n  \"newImageDisplayName\": \"\",\n  \"newImageTags\": \"\",\n  \"dryRun\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"existingImageName\": \"\",\n  \"newImageName\": \"\",\n  \"newImageDescription\": \"\",\n  \"newImageDisplayName\": \"\",\n  \"newImageTags\": \"\",\n  \"dryRun\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage";

    let payload = json!({
        "existingImageName": "",
        "newImageName": "",
        "newImageDescription": "",
        "newImageDisplayName": "",
        "newImageTags": "",
        "dryRun": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "existingImageName": "",
  "newImageName": "",
  "newImageDescription": "",
  "newImageDisplayName": "",
  "newImageTags": "",
  "dryRun": ""
}'

echo '{
  "existingImageName": "",
  "newImageName": "",
  "newImageDescription": "",
  "newImageDisplayName": "",
  "newImageTags": "",
  "dryRun": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "existingImageName": "",\n  "newImageName": "",\n  "newImageDescription": "",\n  "newImageDisplayName": "",\n  "newImageTags": "",\n  "dryRun": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "existingImageName": "",
  "newImageName": "",
  "newImageDescription": "",
  "newImageDisplayName": "",
  "newImageTags": "",
  "dryRun": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUpdatedImage")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateUsageReportSubscription

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription

HEADERS

X-Amz-Target

BODY json

{}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription" {:headers {:x-amz-target ""}
                                                                                                                :content-type :json})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription"

	payload := strings.NewReader("{}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{}")
  .asString();

const data = JSON.stringify({});

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=PhotonAdminProxyService.CreateUsageReportSubscription');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{}'
};

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=PhotonAdminProxyService.CreateUsageReportSubscription',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({});

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=PhotonAdminProxyService.CreateUsageReportSubscription',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {}
};

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=PhotonAdminProxyService.CreateUsageReportSubscription';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{  };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription"

payload = {}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription"

payload <- "{}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription";

    let payload = json!({});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{}'

echo '{}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUsageReportSubscription")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateUser

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser

HEADERS

X-Amz-Target

BODY json

{
  "UserName": "",
  "MessageAction": "",
  "FirstName": "",
  "LastName": "",
  "AuthenticationType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserName\": \"\",\n  \"MessageAction\": \"\",\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"AuthenticationType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser" {:headers {:x-amz-target ""}
                                                                                             :content-type :json
                                                                                             :form-params {:UserName ""
                                                                                                           :MessageAction ""
                                                                                                           :FirstName ""
                                                                                                           :LastName ""
                                                                                                           :AuthenticationType ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserName\": \"\",\n  \"MessageAction\": \"\",\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"AuthenticationType\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserName\": \"\",\n  \"MessageAction\": \"\",\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"AuthenticationType\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserName\": \"\",\n  \"MessageAction\": \"\",\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"AuthenticationType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser"

	payload := strings.NewReader("{\n  \"UserName\": \"\",\n  \"MessageAction\": \"\",\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"AuthenticationType\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 108

{
  "UserName": "",
  "MessageAction": "",
  "FirstName": "",
  "LastName": "",
  "AuthenticationType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserName\": \"\",\n  \"MessageAction\": \"\",\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"AuthenticationType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserName\": \"\",\n  \"MessageAction\": \"\",\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"AuthenticationType\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserName\": \"\",\n  \"MessageAction\": \"\",\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"AuthenticationType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserName\": \"\",\n  \"MessageAction\": \"\",\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"AuthenticationType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserName: '',
  MessageAction: '',
  FirstName: '',
  LastName: '',
  AuthenticationType: ''
});

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=PhotonAdminProxyService.CreateUser');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    UserName: '',
    MessageAction: '',
    FirstName: '',
    LastName: '',
    AuthenticationType: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserName":"","MessageAction":"","FirstName":"","LastName":"","AuthenticationType":""}'
};

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=PhotonAdminProxyService.CreateUser',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserName": "",\n  "MessageAction": "",\n  "FirstName": "",\n  "LastName": "",\n  "AuthenticationType": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserName\": \"\",\n  \"MessageAction\": \"\",\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"AuthenticationType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  UserName: '',
  MessageAction: '',
  FirstName: '',
  LastName: '',
  AuthenticationType: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    UserName: '',
    MessageAction: '',
    FirstName: '',
    LastName: '',
    AuthenticationType: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserName: '',
  MessageAction: '',
  FirstName: '',
  LastName: '',
  AuthenticationType: ''
});

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=PhotonAdminProxyService.CreateUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    UserName: '',
    MessageAction: '',
    FirstName: '',
    LastName: '',
    AuthenticationType: ''
  }
};

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=PhotonAdminProxyService.CreateUser';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserName":"","MessageAction":"","FirstName":"","LastName":"","AuthenticationType":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserName": @"",
                              @"MessageAction": @"",
                              @"FirstName": @"",
                              @"LastName": @"",
                              @"AuthenticationType": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserName\": \"\",\n  \"MessageAction\": \"\",\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"AuthenticationType\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserName' => '',
    'MessageAction' => '',
    'FirstName' => '',
    'LastName' => '',
    'AuthenticationType' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser', [
  'body' => '{
  "UserName": "",
  "MessageAction": "",
  "FirstName": "",
  "LastName": "",
  "AuthenticationType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserName' => '',
  'MessageAction' => '',
  'FirstName' => '',
  'LastName' => '',
  'AuthenticationType' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserName' => '',
  'MessageAction' => '',
  'FirstName' => '',
  'LastName' => '',
  'AuthenticationType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserName": "",
  "MessageAction": "",
  "FirstName": "",
  "LastName": "",
  "AuthenticationType": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserName": "",
  "MessageAction": "",
  "FirstName": "",
  "LastName": "",
  "AuthenticationType": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserName\": \"\",\n  \"MessageAction\": \"\",\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"AuthenticationType\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser"

payload = {
    "UserName": "",
    "MessageAction": "",
    "FirstName": "",
    "LastName": "",
    "AuthenticationType": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser"

payload <- "{\n  \"UserName\": \"\",\n  \"MessageAction\": \"\",\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"AuthenticationType\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserName\": \"\",\n  \"MessageAction\": \"\",\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"AuthenticationType\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserName\": \"\",\n  \"MessageAction\": \"\",\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"AuthenticationType\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser";

    let payload = json!({
        "UserName": "",
        "MessageAction": "",
        "FirstName": "",
        "LastName": "",
        "AuthenticationType": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserName": "",
  "MessageAction": "",
  "FirstName": "",
  "LastName": "",
  "AuthenticationType": ""
}'

echo '{
  "UserName": "",
  "MessageAction": "",
  "FirstName": "",
  "LastName": "",
  "AuthenticationType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserName": "",\n  "MessageAction": "",\n  "FirstName": "",\n  "LastName": "",\n  "AuthenticationType": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserName": "",
  "MessageAction": "",
  "FirstName": "",
  "LastName": "",
  "AuthenticationType": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.CreateUser")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteAppBlock

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock

HEADERS

X-Amz-Target

BODY json

{
  "Name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock" {:headers {:x-amz-target ""}
                                                                                                 :content-type :json
                                                                                                 :form-params {:Name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock"

	payload := strings.NewReader("{\n  \"Name\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "Name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock', [
  'body' => '{
  "Name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock"

payload = { "Name": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock"

payload <- "{\n  \"Name\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock";

    let payload = json!({"Name": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": ""
}'

echo '{
  "Name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["Name": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteAppBlock")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteApplication

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication

HEADERS

X-Amz-Target

BODY json

{
  "Name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication" {:headers {:x-amz-target ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:Name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication"

	payload := strings.NewReader("{\n  \"Name\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "Name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication', [
  'body' => '{
  "Name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication"

payload = { "Name": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication"

payload <- "{\n  \"Name\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication";

    let payload = json!({"Name": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": ""
}'

echo '{
  "Name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["Name": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteApplication")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteDirectoryConfig

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig

HEADERS

X-Amz-Target

BODY json

{
  "DirectoryName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"DirectoryName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:DirectoryName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"DirectoryName\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"DirectoryName\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DirectoryName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig"

	payload := strings.NewReader("{\n  \"DirectoryName\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 25

{
  "DirectoryName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DirectoryName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"DirectoryName\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"DirectoryName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"DirectoryName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  DirectoryName: ''
});

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=PhotonAdminProxyService.DeleteDirectoryConfig');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {DirectoryName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DirectoryName":""}'
};

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=PhotonAdminProxyService.DeleteDirectoryConfig',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DirectoryName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DirectoryName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({DirectoryName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {DirectoryName: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  DirectoryName: ''
});

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=PhotonAdminProxyService.DeleteDirectoryConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {DirectoryName: ''}
};

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=PhotonAdminProxyService.DeleteDirectoryConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DirectoryName":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"DirectoryName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"DirectoryName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'DirectoryName' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig', [
  'body' => '{
  "DirectoryName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DirectoryName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'DirectoryName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DirectoryName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DirectoryName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"DirectoryName\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig"

payload = { "DirectoryName": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig"

payload <- "{\n  \"DirectoryName\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"DirectoryName\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"DirectoryName\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig";

    let payload = json!({"DirectoryName": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "DirectoryName": ""
}'

echo '{
  "DirectoryName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "DirectoryName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["DirectoryName": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteDirectoryConfig")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteEntitlement

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement

HEADERS

X-Amz-Target

BODY json

{
  "Name": "",
  "StackName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"StackName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement" {:headers {:x-amz-target ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:Name ""
                                                                                                                  :StackName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"StackName\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"StackName\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"StackName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"StackName\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 35

{
  "Name": "",
  "StackName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"StackName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"StackName\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"StackName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"StackName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  StackName: ''
});

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=PhotonAdminProxyService.DeleteEntitlement');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', StackName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","StackName":""}'
};

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=PhotonAdminProxyService.DeleteEntitlement',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "StackName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"StackName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Name: '', StackName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: '', StackName: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: '',
  StackName: ''
});

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=PhotonAdminProxyService.DeleteEntitlement',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', StackName: ''}
};

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=PhotonAdminProxyService.DeleteEntitlement';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","StackName":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"StackName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"StackName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'StackName' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement', [
  'body' => '{
  "Name": "",
  "StackName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'StackName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => '',
  'StackName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "StackName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "StackName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\",\n  \"StackName\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement"

payload = {
    "Name": "",
    "StackName": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement"

payload <- "{\n  \"Name\": \"\",\n  \"StackName\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"StackName\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\",\n  \"StackName\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement";

    let payload = json!({
        "Name": "",
        "StackName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": "",
  "StackName": ""
}'

echo '{
  "Name": "",
  "StackName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "StackName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "StackName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteEntitlement")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteFleet

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet

HEADERS

X-Amz-Target

BODY json

{
  "Name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet" {:headers {:x-amz-target ""}
                                                                                              :content-type :json
                                                                                              :form-params {:Name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet"

	payload := strings.NewReader("{\n  \"Name\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "Name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet', [
  'body' => '{
  "Name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet"

payload = { "Name": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet"

payload <- "{\n  \"Name\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet";

    let payload = json!({"Name": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": ""
}'

echo '{
  "Name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["Name": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteFleet")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteImage

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage

HEADERS

X-Amz-Target

BODY json

{
  "Name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage" {:headers {:x-amz-target ""}
                                                                                              :content-type :json
                                                                                              :form-params {:Name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage"

	payload := strings.NewReader("{\n  \"Name\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "Name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage', [
  'body' => '{
  "Name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage"

payload = { "Name": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage"

payload <- "{\n  \"Name\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage";

    let payload = json!({"Name": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": ""
}'

echo '{
  "Name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["Name": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImage")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteImageBuilder

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder

HEADERS

X-Amz-Target

BODY json

{
  "Name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:Name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder"

	payload := strings.NewReader("{\n  \"Name\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "Name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder', [
  'body' => '{
  "Name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder"

payload = { "Name": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder"

payload <- "{\n  \"Name\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder";

    let payload = json!({"Name": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": ""
}'

echo '{
  "Name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["Name": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImageBuilder")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteImagePermissions

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions

HEADERS

X-Amz-Target

BODY json

{
  "Name": "",
  "SharedAccountId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:Name ""
                                                                                                                       :SharedAccountId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 41

{
  "Name": "",
  "SharedAccountId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  SharedAccountId: ''
});

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=PhotonAdminProxyService.DeleteImagePermissions');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', SharedAccountId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","SharedAccountId":""}'
};

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=PhotonAdminProxyService.DeleteImagePermissions',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "SharedAccountId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Name: '', SharedAccountId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: '', SharedAccountId: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: '',
  SharedAccountId: ''
});

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=PhotonAdminProxyService.DeleteImagePermissions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', SharedAccountId: ''}
};

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=PhotonAdminProxyService.DeleteImagePermissions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","SharedAccountId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"SharedAccountId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'SharedAccountId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions', [
  'body' => '{
  "Name": "",
  "SharedAccountId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'SharedAccountId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => '',
  'SharedAccountId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "SharedAccountId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "SharedAccountId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions"

payload = {
    "Name": "",
    "SharedAccountId": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions"

payload <- "{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions";

    let payload = json!({
        "Name": "",
        "SharedAccountId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": "",
  "SharedAccountId": ""
}'

echo '{
  "Name": "",
  "SharedAccountId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "SharedAccountId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "SharedAccountId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteImagePermissions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteStack

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack

HEADERS

X-Amz-Target

BODY json

{
  "Name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack" {:headers {:x-amz-target ""}
                                                                                              :content-type :json
                                                                                              :form-params {:Name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack"

	payload := strings.NewReader("{\n  \"Name\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "Name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack', [
  'body' => '{
  "Name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack"

payload = { "Name": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack"

payload <- "{\n  \"Name\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack";

    let payload = json!({"Name": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": ""
}'

echo '{
  "Name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["Name": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteStack")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteUsageReportSubscription

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription

HEADERS

X-Amz-Target

BODY json

{}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription" {:headers {:x-amz-target ""}
                                                                                                                :content-type :json})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription"

	payload := strings.NewReader("{}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{}")
  .asString();

const data = JSON.stringify({});

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=PhotonAdminProxyService.DeleteUsageReportSubscription');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{}'
};

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=PhotonAdminProxyService.DeleteUsageReportSubscription',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({});

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=PhotonAdminProxyService.DeleteUsageReportSubscription',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {}
};

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=PhotonAdminProxyService.DeleteUsageReportSubscription';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{  };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription"

payload = {}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription"

payload <- "{}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription";

    let payload = json!({});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{}'

echo '{}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUsageReportSubscription")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteUser

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser

HEADERS

X-Amz-Target

BODY json

{
  "UserName": "",
  "AuthenticationType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser" {:headers {:x-amz-target ""}
                                                                                             :content-type :json
                                                                                             :form-params {:UserName ""
                                                                                                           :AuthenticationType ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser"

	payload := strings.NewReader("{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 48

{
  "UserName": "",
  "AuthenticationType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserName: '',
  AuthenticationType: ''
});

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=PhotonAdminProxyService.DeleteUser');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserName: '', AuthenticationType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserName":"","AuthenticationType":""}'
};

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=PhotonAdminProxyService.DeleteUser',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserName": "",\n  "AuthenticationType": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserName: '', AuthenticationType: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserName: '', AuthenticationType: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserName: '',
  AuthenticationType: ''
});

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=PhotonAdminProxyService.DeleteUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserName: '', AuthenticationType: ''}
};

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=PhotonAdminProxyService.DeleteUser';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserName":"","AuthenticationType":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserName": @"",
                              @"AuthenticationType": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserName' => '',
    'AuthenticationType' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser', [
  'body' => '{
  "UserName": "",
  "AuthenticationType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserName' => '',
  'AuthenticationType' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserName' => '',
  'AuthenticationType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserName": "",
  "AuthenticationType": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserName": "",
  "AuthenticationType": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser"

payload = {
    "UserName": "",
    "AuthenticationType": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser"

payload <- "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser";

    let payload = json!({
        "UserName": "",
        "AuthenticationType": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserName": "",
  "AuthenticationType": ""
}'

echo '{
  "UserName": "",
  "AuthenticationType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserName": "",\n  "AuthenticationType": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserName": "",
  "AuthenticationType": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DeleteUser")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DescribeAppBlocks

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks

HEADERS

X-Amz-Target

BODY json

{
  "Arns": "",
  "NextToken": "",
  "MaxResults": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks" {:headers {:x-amz-target ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:Arns ""
                                                                                                                  :NextToken ""
                                                                                                                  :MaxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks"

	payload := strings.NewReader("{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 55

{
  "Arns": "",
  "NextToken": "",
  "MaxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Arns: '',
  NextToken: '',
  MaxResults: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Arns: '', NextToken: '', MaxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Arns":"","NextToken":"","MaxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Arns": "",\n  "NextToken": "",\n  "MaxResults": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Arns: '', NextToken: '', MaxResults: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Arns: '', NextToken: '', MaxResults: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Arns: '',
  NextToken: '',
  MaxResults: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Arns: '', NextToken: '', MaxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Arns":"","NextToken":"","MaxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Arns": @"",
                              @"NextToken": @"",
                              @"MaxResults": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Arns' => '',
    'NextToken' => '',
    'MaxResults' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks', [
  'body' => '{
  "Arns": "",
  "NextToken": "",
  "MaxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Arns' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Arns' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Arns": "",
  "NextToken": "",
  "MaxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Arns": "",
  "NextToken": "",
  "MaxResults": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks"

payload = {
    "Arns": "",
    "NextToken": "",
    "MaxResults": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks"

payload <- "{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks";

    let payload = json!({
        "Arns": "",
        "NextToken": "",
        "MaxResults": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Arns": "",
  "NextToken": "",
  "MaxResults": ""
}'

echo '{
  "Arns": "",
  "NextToken": "",
  "MaxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Arns": "",\n  "NextToken": "",\n  "MaxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Arns": "",
  "NextToken": "",
  "MaxResults": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeAppBlocks")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DescribeApplicationFleetAssociations

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations

HEADERS

X-Amz-Target

BODY json

{
  "FleetName": "",
  "ApplicationArn": "",
  "MaxResults": "",
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations" {:headers {:x-amz-target ""}
                                                                                                                       :content-type :json
                                                                                                                       :form-params {:FleetName ""
                                                                                                                                     :ApplicationArn ""
                                                                                                                                     :MaxResults ""
                                                                                                                                     :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations"

	payload := strings.NewReader("{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 84

{
  "FleetName": "",
  "ApplicationArn": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  FleetName: '',
  ApplicationArn: '',
  MaxResults: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {FleetName: '', ApplicationArn: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FleetName":"","ApplicationArn":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "FleetName": "",\n  "ApplicationArn": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({FleetName: '', ApplicationArn: '', MaxResults: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {FleetName: '', ApplicationArn: '', MaxResults: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  FleetName: '',
  ApplicationArn: '',
  MaxResults: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {FleetName: '', ApplicationArn: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FleetName":"","ApplicationArn":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"FleetName": @"",
                              @"ApplicationArn": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'FleetName' => '',
    'ApplicationArn' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations', [
  'body' => '{
  "FleetName": "",
  "ApplicationArn": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'FleetName' => '',
  'ApplicationArn' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'FleetName' => '',
  'ApplicationArn' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FleetName": "",
  "ApplicationArn": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FleetName": "",
  "ApplicationArn": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations"

payload = {
    "FleetName": "",
    "ApplicationArn": "",
    "MaxResults": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations"

payload <- "{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations";

    let payload = json!({
        "FleetName": "",
        "ApplicationArn": "",
        "MaxResults": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "FleetName": "",
  "ApplicationArn": "",
  "MaxResults": "",
  "NextToken": ""
}'

echo '{
  "FleetName": "",
  "ApplicationArn": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "FleetName": "",\n  "ApplicationArn": "",\n  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "FleetName": "",
  "ApplicationArn": "",
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplicationFleetAssociations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DescribeApplications

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications

HEADERS

X-Amz-Target

BODY json

{
  "Arns": "",
  "NextToken": "",
  "MaxResults": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications" {:headers {:x-amz-target ""}
                                                                                                       :content-type :json
                                                                                                       :form-params {:Arns ""
                                                                                                                     :NextToken ""
                                                                                                                     :MaxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications"

	payload := strings.NewReader("{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 55

{
  "Arns": "",
  "NextToken": "",
  "MaxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Arns: '',
  NextToken: '',
  MaxResults: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Arns: '', NextToken: '', MaxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Arns":"","NextToken":"","MaxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Arns": "",\n  "NextToken": "",\n  "MaxResults": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Arns: '', NextToken: '', MaxResults: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Arns: '', NextToken: '', MaxResults: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Arns: '',
  NextToken: '',
  MaxResults: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Arns: '', NextToken: '', MaxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Arns":"","NextToken":"","MaxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Arns": @"",
                              @"NextToken": @"",
                              @"MaxResults": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Arns' => '',
    'NextToken' => '',
    'MaxResults' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications', [
  'body' => '{
  "Arns": "",
  "NextToken": "",
  "MaxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Arns' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Arns' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Arns": "",
  "NextToken": "",
  "MaxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Arns": "",
  "NextToken": "",
  "MaxResults": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications"

payload = {
    "Arns": "",
    "NextToken": "",
    "MaxResults": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications"

payload <- "{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Arns\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications";

    let payload = json!({
        "Arns": "",
        "NextToken": "",
        "MaxResults": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Arns": "",
  "NextToken": "",
  "MaxResults": ""
}'

echo '{
  "Arns": "",
  "NextToken": "",
  "MaxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Arns": "",\n  "NextToken": "",\n  "MaxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Arns": "",
  "NextToken": "",
  "MaxResults": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeApplications")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DescribeDirectoryConfigs

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs

HEADERS

X-Amz-Target

BODY json

{
  "DirectoryNames": "",
  "MaxResults": "",
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"DirectoryNames\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:DirectoryNames ""
                                                                                                                         :MaxResults ""
                                                                                                                         :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"DirectoryNames\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"DirectoryNames\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DirectoryNames\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs"

	payload := strings.NewReader("{\n  \"DirectoryNames\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 65

{
  "DirectoryNames": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DirectoryNames\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"DirectoryNames\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"DirectoryNames\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"DirectoryNames\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  DirectoryNames: '',
  MaxResults: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {DirectoryNames: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DirectoryNames":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DirectoryNames": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DirectoryNames\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({DirectoryNames: '', MaxResults: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {DirectoryNames: '', MaxResults: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  DirectoryNames: '',
  MaxResults: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {DirectoryNames: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DirectoryNames":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"DirectoryNames": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"DirectoryNames\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'DirectoryNames' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs', [
  'body' => '{
  "DirectoryNames": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DirectoryNames' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'DirectoryNames' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DirectoryNames": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DirectoryNames": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"DirectoryNames\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs"

payload = {
    "DirectoryNames": "",
    "MaxResults": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs"

payload <- "{\n  \"DirectoryNames\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"DirectoryNames\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"DirectoryNames\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs";

    let payload = json!({
        "DirectoryNames": "",
        "MaxResults": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "DirectoryNames": "",
  "MaxResults": "",
  "NextToken": ""
}'

echo '{
  "DirectoryNames": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "DirectoryNames": "",\n  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "DirectoryNames": "",
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeDirectoryConfigs")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DescribeEntitlements

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements

HEADERS

X-Amz-Target

BODY json

{
  "Name": "",
  "StackName": "",
  "NextToken": "",
  "MaxResults": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements" {:headers {:x-amz-target ""}
                                                                                                       :content-type :json
                                                                                                       :form-params {:Name ""
                                                                                                                     :StackName ""
                                                                                                                     :NextToken ""
                                                                                                                     :MaxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 74

{
  "Name": "",
  "StackName": "",
  "NextToken": "",
  "MaxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  StackName: '',
  NextToken: '',
  MaxResults: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', StackName: '', NextToken: '', MaxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","StackName":"","NextToken":"","MaxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "StackName": "",\n  "NextToken": "",\n  "MaxResults": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Name: '', StackName: '', NextToken: '', MaxResults: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: '', StackName: '', NextToken: '', MaxResults: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: '',
  StackName: '',
  NextToken: '',
  MaxResults: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', StackName: '', NextToken: '', MaxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","StackName":"","NextToken":"","MaxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"StackName": @"",
                              @"NextToken": @"",
                              @"MaxResults": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'StackName' => '',
    'NextToken' => '',
    'MaxResults' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements', [
  'body' => '{
  "Name": "",
  "StackName": "",
  "NextToken": "",
  "MaxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'StackName' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => '',
  'StackName' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "StackName": "",
  "NextToken": "",
  "MaxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "StackName": "",
  "NextToken": "",
  "MaxResults": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements"

payload = {
    "Name": "",
    "StackName": "",
    "NextToken": "",
    "MaxResults": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements"

payload <- "{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements";

    let payload = json!({
        "Name": "",
        "StackName": "",
        "NextToken": "",
        "MaxResults": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": "",
  "StackName": "",
  "NextToken": "",
  "MaxResults": ""
}'

echo '{
  "Name": "",
  "StackName": "",
  "NextToken": "",
  "MaxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "StackName": "",\n  "NextToken": "",\n  "MaxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "StackName": "",
  "NextToken": "",
  "MaxResults": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeEntitlements")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DescribeFleets

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets

HEADERS

X-Amz-Target

BODY json

{
  "Names": "",
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets" {:headers {:x-amz-target ""}
                                                                                                 :content-type :json
                                                                                                 :form-params {:Names ""
                                                                                                               :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets"

	payload := strings.NewReader("{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 36

{
  "Names": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Names: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Names: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Names":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Names": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Names: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Names: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Names: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Names: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Names":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Names": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Names' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets', [
  'body' => '{
  "Names": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Names' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Names' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Names": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Names": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets"

payload = {
    "Names": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets"

payload <- "{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets";

    let payload = json!({
        "Names": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Names": "",
  "NextToken": ""
}'

echo '{
  "Names": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Names": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Names": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeFleets")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DescribeImageBuilders

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders

HEADERS

X-Amz-Target

BODY json

{
  "Names": "",
  "MaxResults": "",
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Names\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:Names ""
                                                                                                                      :MaxResults ""
                                                                                                                      :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Names\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Names\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Names\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders"

	payload := strings.NewReader("{\n  \"Names\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 56

{
  "Names": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Names\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Names\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Names\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Names\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Names: '',
  MaxResults: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Names: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Names":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Names": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Names\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Names: '', MaxResults: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Names: '', MaxResults: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Names: '',
  MaxResults: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Names: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Names":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Names": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Names\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Names' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders', [
  'body' => '{
  "Names": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Names' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Names' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Names": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Names": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Names\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders"

payload = {
    "Names": "",
    "MaxResults": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders"

payload <- "{\n  \"Names\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Names\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Names\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders";

    let payload = json!({
        "Names": "",
        "MaxResults": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Names": "",
  "MaxResults": "",
  "NextToken": ""
}'

echo '{
  "Names": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Names": "",\n  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Names": "",
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImageBuilders")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DescribeImagePermissions

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions

HEADERS

X-Amz-Target

BODY json

{
  "Name": "",
  "MaxResults": "",
  "SharedAwsAccountIds": "",
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"MaxResults\": \"\",\n  \"SharedAwsAccountIds\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:Name ""
                                                                                                                         :MaxResults ""
                                                                                                                         :SharedAwsAccountIds ""
                                                                                                                         :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"MaxResults\": \"\",\n  \"SharedAwsAccountIds\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"MaxResults\": \"\",\n  \"SharedAwsAccountIds\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"MaxResults\": \"\",\n  \"SharedAwsAccountIds\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"MaxResults\": \"\",\n  \"SharedAwsAccountIds\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 84

{
  "Name": "",
  "MaxResults": "",
  "SharedAwsAccountIds": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"MaxResults\": \"\",\n  \"SharedAwsAccountIds\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"MaxResults\": \"\",\n  \"SharedAwsAccountIds\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"MaxResults\": \"\",\n  \"SharedAwsAccountIds\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"MaxResults\": \"\",\n  \"SharedAwsAccountIds\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  MaxResults: '',
  SharedAwsAccountIds: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', MaxResults: '', SharedAwsAccountIds: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","MaxResults":"","SharedAwsAccountIds":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "MaxResults": "",\n  "SharedAwsAccountIds": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"MaxResults\": \"\",\n  \"SharedAwsAccountIds\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Name: '', MaxResults: '', SharedAwsAccountIds: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: '', MaxResults: '', SharedAwsAccountIds: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: '',
  MaxResults: '',
  SharedAwsAccountIds: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', MaxResults: '', SharedAwsAccountIds: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","MaxResults":"","SharedAwsAccountIds":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"MaxResults": @"",
                              @"SharedAwsAccountIds": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"MaxResults\": \"\",\n  \"SharedAwsAccountIds\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'MaxResults' => '',
    'SharedAwsAccountIds' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions', [
  'body' => '{
  "Name": "",
  "MaxResults": "",
  "SharedAwsAccountIds": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'MaxResults' => '',
  'SharedAwsAccountIds' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => '',
  'MaxResults' => '',
  'SharedAwsAccountIds' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "MaxResults": "",
  "SharedAwsAccountIds": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "MaxResults": "",
  "SharedAwsAccountIds": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\",\n  \"MaxResults\": \"\",\n  \"SharedAwsAccountIds\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions"

payload = {
    "Name": "",
    "MaxResults": "",
    "SharedAwsAccountIds": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions"

payload <- "{\n  \"Name\": \"\",\n  \"MaxResults\": \"\",\n  \"SharedAwsAccountIds\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"MaxResults\": \"\",\n  \"SharedAwsAccountIds\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\",\n  \"MaxResults\": \"\",\n  \"SharedAwsAccountIds\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions";

    let payload = json!({
        "Name": "",
        "MaxResults": "",
        "SharedAwsAccountIds": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": "",
  "MaxResults": "",
  "SharedAwsAccountIds": "",
  "NextToken": ""
}'

echo '{
  "Name": "",
  "MaxResults": "",
  "SharedAwsAccountIds": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "MaxResults": "",\n  "SharedAwsAccountIds": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "MaxResults": "",
  "SharedAwsAccountIds": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImagePermissions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DescribeImages

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages

HEADERS

X-Amz-Target

BODY json

{
  "Names": "",
  "Arns": "",
  "Type": "",
  "NextToken": "",
  "MaxResults": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Names\": \"\",\n  \"Arns\": \"\",\n  \"Type\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages" {:headers {:x-amz-target ""}
                                                                                                 :content-type :json
                                                                                                 :form-params {:Names ""
                                                                                                               :Arns ""
                                                                                                               :Type ""
                                                                                                               :NextToken ""
                                                                                                               :MaxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Names\": \"\",\n  \"Arns\": \"\",\n  \"Type\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Names\": \"\",\n  \"Arns\": \"\",\n  \"Type\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Names\": \"\",\n  \"Arns\": \"\",\n  \"Type\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages"

	payload := strings.NewReader("{\n  \"Names\": \"\",\n  \"Arns\": \"\",\n  \"Type\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 84

{
  "Names": "",
  "Arns": "",
  "Type": "",
  "NextToken": "",
  "MaxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Names\": \"\",\n  \"Arns\": \"\",\n  \"Type\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Names\": \"\",\n  \"Arns\": \"\",\n  \"Type\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Names\": \"\",\n  \"Arns\": \"\",\n  \"Type\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Names\": \"\",\n  \"Arns\": \"\",\n  \"Type\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Names: '',
  Arns: '',
  Type: '',
  NextToken: '',
  MaxResults: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Names: '', Arns: '', Type: '', NextToken: '', MaxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Names":"","Arns":"","Type":"","NextToken":"","MaxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Names": "",\n  "Arns": "",\n  "Type": "",\n  "NextToken": "",\n  "MaxResults": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Names\": \"\",\n  \"Arns\": \"\",\n  \"Type\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Names: '', Arns: '', Type: '', NextToken: '', MaxResults: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Names: '', Arns: '', Type: '', NextToken: '', MaxResults: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Names: '',
  Arns: '',
  Type: '',
  NextToken: '',
  MaxResults: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Names: '', Arns: '', Type: '', NextToken: '', MaxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Names":"","Arns":"","Type":"","NextToken":"","MaxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Names": @"",
                              @"Arns": @"",
                              @"Type": @"",
                              @"NextToken": @"",
                              @"MaxResults": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Names\": \"\",\n  \"Arns\": \"\",\n  \"Type\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Names' => '',
    'Arns' => '',
    'Type' => '',
    'NextToken' => '',
    'MaxResults' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages', [
  'body' => '{
  "Names": "",
  "Arns": "",
  "Type": "",
  "NextToken": "",
  "MaxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Names' => '',
  'Arns' => '',
  'Type' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Names' => '',
  'Arns' => '',
  'Type' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Names": "",
  "Arns": "",
  "Type": "",
  "NextToken": "",
  "MaxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Names": "",
  "Arns": "",
  "Type": "",
  "NextToken": "",
  "MaxResults": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Names\": \"\",\n  \"Arns\": \"\",\n  \"Type\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages"

payload = {
    "Names": "",
    "Arns": "",
    "Type": "",
    "NextToken": "",
    "MaxResults": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages"

payload <- "{\n  \"Names\": \"\",\n  \"Arns\": \"\",\n  \"Type\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Names\": \"\",\n  \"Arns\": \"\",\n  \"Type\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Names\": \"\",\n  \"Arns\": \"\",\n  \"Type\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages";

    let payload = json!({
        "Names": "",
        "Arns": "",
        "Type": "",
        "NextToken": "",
        "MaxResults": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Names": "",
  "Arns": "",
  "Type": "",
  "NextToken": "",
  "MaxResults": ""
}'

echo '{
  "Names": "",
  "Arns": "",
  "Type": "",
  "NextToken": "",
  "MaxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Names": "",\n  "Arns": "",\n  "Type": "",\n  "NextToken": "",\n  "MaxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Names": "",
  "Arns": "",
  "Type": "",
  "NextToken": "",
  "MaxResults": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeImages")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DescribeSessions

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions

HEADERS

X-Amz-Target

BODY json

{
  "StackName": "",
  "FleetName": "",
  "UserId": "",
  "NextToken": "",
  "Limit": "",
  "AuthenticationType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"NextToken\": \"\",\n  \"Limit\": \"\",\n  \"AuthenticationType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions" {:headers {:x-amz-target ""}
                                                                                                   :content-type :json
                                                                                                   :form-params {:StackName ""
                                                                                                                 :FleetName ""
                                                                                                                 :UserId ""
                                                                                                                 :NextToken ""
                                                                                                                 :Limit ""
                                                                                                                 :AuthenticationType ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"NextToken\": \"\",\n  \"Limit\": \"\",\n  \"AuthenticationType\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"NextToken\": \"\",\n  \"Limit\": \"\",\n  \"AuthenticationType\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"NextToken\": \"\",\n  \"Limit\": \"\",\n  \"AuthenticationType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions"

	payload := strings.NewReader("{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"NextToken\": \"\",\n  \"Limit\": \"\",\n  \"AuthenticationType\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 118

{
  "StackName": "",
  "FleetName": "",
  "UserId": "",
  "NextToken": "",
  "Limit": "",
  "AuthenticationType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"NextToken\": \"\",\n  \"Limit\": \"\",\n  \"AuthenticationType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"NextToken\": \"\",\n  \"Limit\": \"\",\n  \"AuthenticationType\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"NextToken\": \"\",\n  \"Limit\": \"\",\n  \"AuthenticationType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"NextToken\": \"\",\n  \"Limit\": \"\",\n  \"AuthenticationType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  StackName: '',
  FleetName: '',
  UserId: '',
  NextToken: '',
  Limit: '',
  AuthenticationType: ''
});

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=PhotonAdminProxyService.DescribeSessions');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    StackName: '',
    FleetName: '',
    UserId: '',
    NextToken: '',
    Limit: '',
    AuthenticationType: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"StackName":"","FleetName":"","UserId":"","NextToken":"","Limit":"","AuthenticationType":""}'
};

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=PhotonAdminProxyService.DescribeSessions',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "StackName": "",\n  "FleetName": "",\n  "UserId": "",\n  "NextToken": "",\n  "Limit": "",\n  "AuthenticationType": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"NextToken\": \"\",\n  \"Limit\": \"\",\n  \"AuthenticationType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  StackName: '',
  FleetName: '',
  UserId: '',
  NextToken: '',
  Limit: '',
  AuthenticationType: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    StackName: '',
    FleetName: '',
    UserId: '',
    NextToken: '',
    Limit: '',
    AuthenticationType: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  StackName: '',
  FleetName: '',
  UserId: '',
  NextToken: '',
  Limit: '',
  AuthenticationType: ''
});

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=PhotonAdminProxyService.DescribeSessions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    StackName: '',
    FleetName: '',
    UserId: '',
    NextToken: '',
    Limit: '',
    AuthenticationType: ''
  }
};

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=PhotonAdminProxyService.DescribeSessions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"StackName":"","FleetName":"","UserId":"","NextToken":"","Limit":"","AuthenticationType":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"StackName": @"",
                              @"FleetName": @"",
                              @"UserId": @"",
                              @"NextToken": @"",
                              @"Limit": @"",
                              @"AuthenticationType": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"NextToken\": \"\",\n  \"Limit\": \"\",\n  \"AuthenticationType\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'StackName' => '',
    'FleetName' => '',
    'UserId' => '',
    'NextToken' => '',
    'Limit' => '',
    'AuthenticationType' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions', [
  'body' => '{
  "StackName": "",
  "FleetName": "",
  "UserId": "",
  "NextToken": "",
  "Limit": "",
  "AuthenticationType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'StackName' => '',
  'FleetName' => '',
  'UserId' => '',
  'NextToken' => '',
  'Limit' => '',
  'AuthenticationType' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'StackName' => '',
  'FleetName' => '',
  'UserId' => '',
  'NextToken' => '',
  'Limit' => '',
  'AuthenticationType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "StackName": "",
  "FleetName": "",
  "UserId": "",
  "NextToken": "",
  "Limit": "",
  "AuthenticationType": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "StackName": "",
  "FleetName": "",
  "UserId": "",
  "NextToken": "",
  "Limit": "",
  "AuthenticationType": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"NextToken\": \"\",\n  \"Limit\": \"\",\n  \"AuthenticationType\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions"

payload = {
    "StackName": "",
    "FleetName": "",
    "UserId": "",
    "NextToken": "",
    "Limit": "",
    "AuthenticationType": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions"

payload <- "{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"NextToken\": \"\",\n  \"Limit\": \"\",\n  \"AuthenticationType\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"NextToken\": \"\",\n  \"Limit\": \"\",\n  \"AuthenticationType\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"StackName\": \"\",\n  \"FleetName\": \"\",\n  \"UserId\": \"\",\n  \"NextToken\": \"\",\n  \"Limit\": \"\",\n  \"AuthenticationType\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions";

    let payload = json!({
        "StackName": "",
        "FleetName": "",
        "UserId": "",
        "NextToken": "",
        "Limit": "",
        "AuthenticationType": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "StackName": "",
  "FleetName": "",
  "UserId": "",
  "NextToken": "",
  "Limit": "",
  "AuthenticationType": ""
}'

echo '{
  "StackName": "",
  "FleetName": "",
  "UserId": "",
  "NextToken": "",
  "Limit": "",
  "AuthenticationType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "StackName": "",\n  "FleetName": "",\n  "UserId": "",\n  "NextToken": "",\n  "Limit": "",\n  "AuthenticationType": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "StackName": "",
  "FleetName": "",
  "UserId": "",
  "NextToken": "",
  "Limit": "",
  "AuthenticationType": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeSessions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DescribeStacks

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks

HEADERS

X-Amz-Target

BODY json

{
  "Names": "",
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks" {:headers {:x-amz-target ""}
                                                                                                 :content-type :json
                                                                                                 :form-params {:Names ""
                                                                                                               :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks"

	payload := strings.NewReader("{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 36

{
  "Names": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Names: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Names: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Names":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Names": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Names: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Names: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Names: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Names: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Names":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Names": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Names' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks', [
  'body' => '{
  "Names": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Names' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Names' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Names": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Names": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks"

payload = {
    "Names": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks"

payload <- "{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Names\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks";

    let payload = json!({
        "Names": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Names": "",
  "NextToken": ""
}'

echo '{
  "Names": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Names": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Names": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeStacks")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DescribeUsageReportSubscriptions

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions

HEADERS

X-Amz-Target

BODY json

{
  "MaxResults": "",
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:MaxResults ""
                                                                                                                                 :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions"

	payload := strings.NewReader("{\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 41

{
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  MaxResults: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({MaxResults: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {MaxResults: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  MaxResults: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"MaxResults": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions', [
  'body' => '{
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'MaxResults' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions"

payload = {
    "MaxResults": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions"

payload <- "{\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions";

    let payload = json!({
        "MaxResults": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "MaxResults": "",
  "NextToken": ""
}'

echo '{
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsageReportSubscriptions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DescribeUserStackAssociations

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations

HEADERS

X-Amz-Target

BODY json

{
  "StackName": "",
  "UserName": "",
  "AuthenticationType": "",
  "MaxResults": "",
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"StackName\": \"\",\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations" {:headers {:x-amz-target ""}
                                                                                                                :content-type :json
                                                                                                                :form-params {:StackName ""
                                                                                                                              :UserName ""
                                                                                                                              :AuthenticationType ""
                                                                                                                              :MaxResults ""
                                                                                                                              :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"StackName\": \"\",\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"StackName\": \"\",\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"StackName\": \"\",\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations"

	payload := strings.NewReader("{\n  \"StackName\": \"\",\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 106

{
  "StackName": "",
  "UserName": "",
  "AuthenticationType": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"StackName\": \"\",\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"StackName\": \"\",\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"StackName\": \"\",\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"StackName\": \"\",\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  StackName: '',
  UserName: '',
  AuthenticationType: '',
  MaxResults: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    StackName: '',
    UserName: '',
    AuthenticationType: '',
    MaxResults: '',
    NextToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"StackName":"","UserName":"","AuthenticationType":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "StackName": "",\n  "UserName": "",\n  "AuthenticationType": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"StackName\": \"\",\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  StackName: '',
  UserName: '',
  AuthenticationType: '',
  MaxResults: '',
  NextToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    StackName: '',
    UserName: '',
    AuthenticationType: '',
    MaxResults: '',
    NextToken: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  StackName: '',
  UserName: '',
  AuthenticationType: '',
  MaxResults: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    StackName: '',
    UserName: '',
    AuthenticationType: '',
    MaxResults: '',
    NextToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"StackName":"","UserName":"","AuthenticationType":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"StackName": @"",
                              @"UserName": @"",
                              @"AuthenticationType": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"StackName\": \"\",\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'StackName' => '',
    'UserName' => '',
    'AuthenticationType' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations', [
  'body' => '{
  "StackName": "",
  "UserName": "",
  "AuthenticationType": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'StackName' => '',
  'UserName' => '',
  'AuthenticationType' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'StackName' => '',
  'UserName' => '',
  'AuthenticationType' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "StackName": "",
  "UserName": "",
  "AuthenticationType": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "StackName": "",
  "UserName": "",
  "AuthenticationType": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"StackName\": \"\",\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations"

payload = {
    "StackName": "",
    "UserName": "",
    "AuthenticationType": "",
    "MaxResults": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations"

payload <- "{\n  \"StackName\": \"\",\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"StackName\": \"\",\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"StackName\": \"\",\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations";

    let payload = json!({
        "StackName": "",
        "UserName": "",
        "AuthenticationType": "",
        "MaxResults": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "StackName": "",
  "UserName": "",
  "AuthenticationType": "",
  "MaxResults": "",
  "NextToken": ""
}'

echo '{
  "StackName": "",
  "UserName": "",
  "AuthenticationType": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "StackName": "",\n  "UserName": "",\n  "AuthenticationType": "",\n  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "StackName": "",
  "UserName": "",
  "AuthenticationType": "",
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUserStackAssociations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DescribeUsers

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers

HEADERS

X-Amz-Target

BODY json

{
  "AuthenticationType": "",
  "MaxResults": "",
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers" {:headers {:x-amz-target ""}
                                                                                                :content-type :json
                                                                                                :form-params {:AuthenticationType ""
                                                                                                              :MaxResults ""
                                                                                                              :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers"

	payload := strings.NewReader("{\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 69

{
  "AuthenticationType": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AuthenticationType: '',
  MaxResults: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AuthenticationType: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AuthenticationType":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AuthenticationType": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({AuthenticationType: '', MaxResults: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AuthenticationType: '', MaxResults: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AuthenticationType: '',
  MaxResults: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AuthenticationType: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AuthenticationType":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AuthenticationType": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'AuthenticationType' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers', [
  'body' => '{
  "AuthenticationType": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AuthenticationType' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AuthenticationType' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AuthenticationType": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AuthenticationType": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers"

payload = {
    "AuthenticationType": "",
    "MaxResults": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers"

payload <- "{\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"AuthenticationType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers";

    let payload = json!({
        "AuthenticationType": "",
        "MaxResults": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AuthenticationType": "",
  "MaxResults": "",
  "NextToken": ""
}'

echo '{
  "AuthenticationType": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AuthenticationType": "",\n  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AuthenticationType": "",
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DescribeUsers")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DisableUser

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser

HEADERS

X-Amz-Target

BODY json

{
  "UserName": "",
  "AuthenticationType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser" {:headers {:x-amz-target ""}
                                                                                              :content-type :json
                                                                                              :form-params {:UserName ""
                                                                                                            :AuthenticationType ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser"

	payload := strings.NewReader("{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 48

{
  "UserName": "",
  "AuthenticationType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserName: '',
  AuthenticationType: ''
});

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=PhotonAdminProxyService.DisableUser');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserName: '', AuthenticationType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserName":"","AuthenticationType":""}'
};

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=PhotonAdminProxyService.DisableUser',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserName": "",\n  "AuthenticationType": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserName: '', AuthenticationType: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserName: '', AuthenticationType: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserName: '',
  AuthenticationType: ''
});

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=PhotonAdminProxyService.DisableUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserName: '', AuthenticationType: ''}
};

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=PhotonAdminProxyService.DisableUser';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserName":"","AuthenticationType":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserName": @"",
                              @"AuthenticationType": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserName' => '',
    'AuthenticationType' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser', [
  'body' => '{
  "UserName": "",
  "AuthenticationType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserName' => '',
  'AuthenticationType' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserName' => '',
  'AuthenticationType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserName": "",
  "AuthenticationType": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserName": "",
  "AuthenticationType": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser"

payload = {
    "UserName": "",
    "AuthenticationType": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser"

payload <- "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser";

    let payload = json!({
        "UserName": "",
        "AuthenticationType": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserName": "",
  "AuthenticationType": ""
}'

echo '{
  "UserName": "",
  "AuthenticationType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserName": "",\n  "AuthenticationType": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserName": "",
  "AuthenticationType": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisableUser")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DisassociateApplicationFleet

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet

HEADERS

X-Amz-Target

BODY json

{
  "FleetName": "",
  "ApplicationArn": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:FleetName ""
                                                                                                                             :ApplicationArn ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet"

	payload := strings.NewReader("{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 45

{
  "FleetName": "",
  "ApplicationArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  FleetName: '',
  ApplicationArn: ''
});

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=PhotonAdminProxyService.DisassociateApplicationFleet');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {FleetName: '', ApplicationArn: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FleetName":"","ApplicationArn":""}'
};

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=PhotonAdminProxyService.DisassociateApplicationFleet',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "FleetName": "",\n  "ApplicationArn": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({FleetName: '', ApplicationArn: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {FleetName: '', ApplicationArn: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  FleetName: '',
  ApplicationArn: ''
});

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=PhotonAdminProxyService.DisassociateApplicationFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {FleetName: '', ApplicationArn: ''}
};

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=PhotonAdminProxyService.DisassociateApplicationFleet';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FleetName":"","ApplicationArn":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"FleetName": @"",
                              @"ApplicationArn": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'FleetName' => '',
    'ApplicationArn' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet', [
  'body' => '{
  "FleetName": "",
  "ApplicationArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'FleetName' => '',
  'ApplicationArn' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'FleetName' => '',
  'ApplicationArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FleetName": "",
  "ApplicationArn": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FleetName": "",
  "ApplicationArn": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet"

payload = {
    "FleetName": "",
    "ApplicationArn": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet"

payload <- "{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"FleetName\": \"\",\n  \"ApplicationArn\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet";

    let payload = json!({
        "FleetName": "",
        "ApplicationArn": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "FleetName": "",
  "ApplicationArn": ""
}'

echo '{
  "FleetName": "",
  "ApplicationArn": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "FleetName": "",\n  "ApplicationArn": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "FleetName": "",
  "ApplicationArn": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFleet")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DisassociateApplicationFromEntitlement

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement

HEADERS

X-Amz-Target

BODY json

{
  "StackName": "",
  "EntitlementName": "",
  "ApplicationIdentifier": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"ApplicationIdentifier\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement" {:headers {:x-amz-target ""}
                                                                                                                         :content-type :json
                                                                                                                         :form-params {:StackName ""
                                                                                                                                       :EntitlementName ""
                                                                                                                                       :ApplicationIdentifier ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"ApplicationIdentifier\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"ApplicationIdentifier\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"ApplicationIdentifier\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement"

	payload := strings.NewReader("{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"ApplicationIdentifier\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 77

{
  "StackName": "",
  "EntitlementName": "",
  "ApplicationIdentifier": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"ApplicationIdentifier\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"ApplicationIdentifier\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"ApplicationIdentifier\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"ApplicationIdentifier\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  StackName: '',
  EntitlementName: '',
  ApplicationIdentifier: ''
});

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=PhotonAdminProxyService.DisassociateApplicationFromEntitlement');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {StackName: '', EntitlementName: '', ApplicationIdentifier: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"StackName":"","EntitlementName":"","ApplicationIdentifier":""}'
};

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=PhotonAdminProxyService.DisassociateApplicationFromEntitlement',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "StackName": "",\n  "EntitlementName": "",\n  "ApplicationIdentifier": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"ApplicationIdentifier\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({StackName: '', EntitlementName: '', ApplicationIdentifier: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {StackName: '', EntitlementName: '', ApplicationIdentifier: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  StackName: '',
  EntitlementName: '',
  ApplicationIdentifier: ''
});

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=PhotonAdminProxyService.DisassociateApplicationFromEntitlement',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {StackName: '', EntitlementName: '', ApplicationIdentifier: ''}
};

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=PhotonAdminProxyService.DisassociateApplicationFromEntitlement';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"StackName":"","EntitlementName":"","ApplicationIdentifier":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"StackName": @"",
                              @"EntitlementName": @"",
                              @"ApplicationIdentifier": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"ApplicationIdentifier\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'StackName' => '',
    'EntitlementName' => '',
    'ApplicationIdentifier' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement', [
  'body' => '{
  "StackName": "",
  "EntitlementName": "",
  "ApplicationIdentifier": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'StackName' => '',
  'EntitlementName' => '',
  'ApplicationIdentifier' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'StackName' => '',
  'EntitlementName' => '',
  'ApplicationIdentifier' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "StackName": "",
  "EntitlementName": "",
  "ApplicationIdentifier": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "StackName": "",
  "EntitlementName": "",
  "ApplicationIdentifier": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"ApplicationIdentifier\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement"

payload = {
    "StackName": "",
    "EntitlementName": "",
    "ApplicationIdentifier": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement"

payload <- "{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"ApplicationIdentifier\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"ApplicationIdentifier\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"ApplicationIdentifier\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement";

    let payload = json!({
        "StackName": "",
        "EntitlementName": "",
        "ApplicationIdentifier": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "StackName": "",
  "EntitlementName": "",
  "ApplicationIdentifier": ""
}'

echo '{
  "StackName": "",
  "EntitlementName": "",
  "ApplicationIdentifier": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "StackName": "",\n  "EntitlementName": "",\n  "ApplicationIdentifier": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "StackName": "",
  "EntitlementName": "",
  "ApplicationIdentifier": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateApplicationFromEntitlement")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DisassociateFleet

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet

HEADERS

X-Amz-Target

BODY json

{
  "FleetName": "",
  "StackName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"FleetName\": \"\",\n  \"StackName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet" {:headers {:x-amz-target ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:FleetName ""
                                                                                                                  :StackName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"FleetName\": \"\",\n  \"StackName\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"FleetName\": \"\",\n  \"StackName\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"FleetName\": \"\",\n  \"StackName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet"

	payload := strings.NewReader("{\n  \"FleetName\": \"\",\n  \"StackName\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "FleetName": "",
  "StackName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"FleetName\": \"\",\n  \"StackName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"FleetName\": \"\",\n  \"StackName\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"FleetName\": \"\",\n  \"StackName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"FleetName\": \"\",\n  \"StackName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  FleetName: '',
  StackName: ''
});

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=PhotonAdminProxyService.DisassociateFleet');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {FleetName: '', StackName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FleetName":"","StackName":""}'
};

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=PhotonAdminProxyService.DisassociateFleet',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "FleetName": "",\n  "StackName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"FleetName\": \"\",\n  \"StackName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({FleetName: '', StackName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {FleetName: '', StackName: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  FleetName: '',
  StackName: ''
});

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=PhotonAdminProxyService.DisassociateFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {FleetName: '', StackName: ''}
};

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=PhotonAdminProxyService.DisassociateFleet';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FleetName":"","StackName":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"FleetName": @"",
                              @"StackName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"FleetName\": \"\",\n  \"StackName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'FleetName' => '',
    'StackName' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet', [
  'body' => '{
  "FleetName": "",
  "StackName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'FleetName' => '',
  'StackName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'FleetName' => '',
  'StackName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FleetName": "",
  "StackName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FleetName": "",
  "StackName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"FleetName\": \"\",\n  \"StackName\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet"

payload = {
    "FleetName": "",
    "StackName": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet"

payload <- "{\n  \"FleetName\": \"\",\n  \"StackName\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"FleetName\": \"\",\n  \"StackName\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"FleetName\": \"\",\n  \"StackName\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet";

    let payload = json!({
        "FleetName": "",
        "StackName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "FleetName": "",
  "StackName": ""
}'

echo '{
  "FleetName": "",
  "StackName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "FleetName": "",\n  "StackName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "FleetName": "",
  "StackName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.DisassociateFleet")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST EnableUser

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser

HEADERS

X-Amz-Target

BODY json

{
  "UserName": "",
  "AuthenticationType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser" {:headers {:x-amz-target ""}
                                                                                             :content-type :json
                                                                                             :form-params {:UserName ""
                                                                                                           :AuthenticationType ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser"

	payload := strings.NewReader("{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 48

{
  "UserName": "",
  "AuthenticationType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserName: '',
  AuthenticationType: ''
});

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=PhotonAdminProxyService.EnableUser');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserName: '', AuthenticationType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserName":"","AuthenticationType":""}'
};

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=PhotonAdminProxyService.EnableUser',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserName": "",\n  "AuthenticationType": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserName: '', AuthenticationType: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserName: '', AuthenticationType: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserName: '',
  AuthenticationType: ''
});

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=PhotonAdminProxyService.EnableUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserName: '', AuthenticationType: ''}
};

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=PhotonAdminProxyService.EnableUser';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserName":"","AuthenticationType":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserName": @"",
                              @"AuthenticationType": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserName' => '',
    'AuthenticationType' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser', [
  'body' => '{
  "UserName": "",
  "AuthenticationType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserName' => '',
  'AuthenticationType' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserName' => '',
  'AuthenticationType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserName": "",
  "AuthenticationType": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserName": "",
  "AuthenticationType": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser"

payload = {
    "UserName": "",
    "AuthenticationType": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser"

payload <- "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserName\": \"\",\n  \"AuthenticationType\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser";

    let payload = json!({
        "UserName": "",
        "AuthenticationType": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserName": "",
  "AuthenticationType": ""
}'

echo '{
  "UserName": "",
  "AuthenticationType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserName": "",\n  "AuthenticationType": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserName": "",
  "AuthenticationType": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.EnableUser")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ExpireSession

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession

HEADERS

X-Amz-Target

BODY json

{
  "SessionId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"SessionId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession" {:headers {:x-amz-target ""}
                                                                                                :content-type :json
                                                                                                :form-params {:SessionId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"SessionId\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"SessionId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"SessionId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession"

	payload := strings.NewReader("{\n  \"SessionId\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 21

{
  "SessionId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"SessionId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"SessionId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"SessionId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"SessionId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  SessionId: ''
});

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=PhotonAdminProxyService.ExpireSession');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {SessionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SessionId":""}'
};

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=PhotonAdminProxyService.ExpireSession',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "SessionId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"SessionId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({SessionId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {SessionId: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  SessionId: ''
});

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=PhotonAdminProxyService.ExpireSession',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {SessionId: ''}
};

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=PhotonAdminProxyService.ExpireSession';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SessionId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"SessionId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"SessionId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'SessionId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession', [
  'body' => '{
  "SessionId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'SessionId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'SessionId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SessionId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SessionId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"SessionId\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession"

payload = { "SessionId": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession"

payload <- "{\n  \"SessionId\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"SessionId\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"SessionId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession";

    let payload = json!({"SessionId": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "SessionId": ""
}'

echo '{
  "SessionId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "SessionId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["SessionId": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ExpireSession")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListAssociatedFleets

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets

HEADERS

X-Amz-Target

BODY json

{
  "StackName": "",
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"StackName\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets" {:headers {:x-amz-target ""}
                                                                                                       :content-type :json
                                                                                                       :form-params {:StackName ""
                                                                                                                     :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"StackName\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"StackName\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"StackName\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets"

	payload := strings.NewReader("{\n  \"StackName\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "StackName": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"StackName\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"StackName\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"StackName\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"StackName\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  StackName: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {StackName: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"StackName":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "StackName": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"StackName\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({StackName: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {StackName: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  StackName: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {StackName: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"StackName":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"StackName": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"StackName\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'StackName' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets', [
  'body' => '{
  "StackName": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'StackName' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'StackName' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "StackName": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "StackName": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"StackName\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets"

payload = {
    "StackName": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets"

payload <- "{\n  \"StackName\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"StackName\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"StackName\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets";

    let payload = json!({
        "StackName": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "StackName": "",
  "NextToken": ""
}'

echo '{
  "StackName": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "StackName": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "StackName": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedFleets")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListAssociatedStacks

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks

HEADERS

X-Amz-Target

BODY json

{
  "FleetName": "",
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"FleetName\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks" {:headers {:x-amz-target ""}
                                                                                                       :content-type :json
                                                                                                       :form-params {:FleetName ""
                                                                                                                     :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"FleetName\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"FleetName\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"FleetName\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks"

	payload := strings.NewReader("{\n  \"FleetName\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "FleetName": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"FleetName\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"FleetName\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"FleetName\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"FleetName\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  FleetName: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {FleetName: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FleetName":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "FleetName": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"FleetName\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({FleetName: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {FleetName: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  FleetName: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {FleetName: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FleetName":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"FleetName": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"FleetName\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'FleetName' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks', [
  'body' => '{
  "FleetName": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'FleetName' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'FleetName' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FleetName": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FleetName": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"FleetName\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks"

payload = {
    "FleetName": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks"

payload <- "{\n  \"FleetName\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"FleetName\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"FleetName\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks";

    let payload = json!({
        "FleetName": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "FleetName": "",
  "NextToken": ""
}'

echo '{
  "FleetName": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "FleetName": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "FleetName": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListAssociatedStacks")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListEntitledApplications

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications

HEADERS

X-Amz-Target

BODY json

{
  "StackName": "",
  "EntitlementName": "",
  "NextToken": "",
  "MaxResults": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:StackName ""
                                                                                                                         :EntitlementName ""
                                                                                                                         :NextToken ""
                                                                                                                         :MaxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications"

	payload := strings.NewReader("{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 85

{
  "StackName": "",
  "EntitlementName": "",
  "NextToken": "",
  "MaxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  StackName: '',
  EntitlementName: '',
  NextToken: '',
  MaxResults: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {StackName: '', EntitlementName: '', NextToken: '', MaxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"StackName":"","EntitlementName":"","NextToken":"","MaxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "StackName": "",\n  "EntitlementName": "",\n  "NextToken": "",\n  "MaxResults": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({StackName: '', EntitlementName: '', NextToken: '', MaxResults: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {StackName: '', EntitlementName: '', NextToken: '', MaxResults: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  StackName: '',
  EntitlementName: '',
  NextToken: '',
  MaxResults: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {StackName: '', EntitlementName: '', NextToken: '', MaxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"StackName":"","EntitlementName":"","NextToken":"","MaxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"StackName": @"",
                              @"EntitlementName": @"",
                              @"NextToken": @"",
                              @"MaxResults": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'StackName' => '',
    'EntitlementName' => '',
    'NextToken' => '',
    'MaxResults' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications', [
  'body' => '{
  "StackName": "",
  "EntitlementName": "",
  "NextToken": "",
  "MaxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'StackName' => '',
  'EntitlementName' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'StackName' => '',
  'EntitlementName' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "StackName": "",
  "EntitlementName": "",
  "NextToken": "",
  "MaxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "StackName": "",
  "EntitlementName": "",
  "NextToken": "",
  "MaxResults": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications"

payload = {
    "StackName": "",
    "EntitlementName": "",
    "NextToken": "",
    "MaxResults": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications"

payload <- "{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"StackName\": \"\",\n  \"EntitlementName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications";

    let payload = json!({
        "StackName": "",
        "EntitlementName": "",
        "NextToken": "",
        "MaxResults": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "StackName": "",
  "EntitlementName": "",
  "NextToken": "",
  "MaxResults": ""
}'

echo '{
  "StackName": "",
  "EntitlementName": "",
  "NextToken": "",
  "MaxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "StackName": "",\n  "EntitlementName": "",\n  "NextToken": "",\n  "MaxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "StackName": "",
  "EntitlementName": "",
  "NextToken": "",
  "MaxResults": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListEntitledApplications")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListTagsForResource

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource

HEADERS

X-Amz-Target

BODY json

{
  "ResourceArn": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"ResourceArn\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:ResourceArn ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ResourceArn\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ResourceArn\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ResourceArn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource"

	payload := strings.NewReader("{\n  \"ResourceArn\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 23

{
  "ResourceArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ResourceArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ResourceArn\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ResourceArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ResourceArn\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ResourceArn: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ResourceArn": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ResourceArn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({ResourceArn: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ResourceArn: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ResourceArn: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ResourceArn": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ResourceArn\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'ResourceArn' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource', [
  'body' => '{
  "ResourceArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ResourceArn' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ResourceArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceArn": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceArn": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ResourceArn\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource"

payload = { "ResourceArn": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource"

payload <- "{\n  \"ResourceArn\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"ResourceArn\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"ResourceArn\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource";

    let payload = json!({"ResourceArn": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceArn": ""
}'

echo '{
  "ResourceArn": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ResourceArn": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["ResourceArn": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.ListTagsForResource")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST StartFleet

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet

HEADERS

X-Amz-Target

BODY json

{
  "Name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet" {:headers {:x-amz-target ""}
                                                                                             :content-type :json
                                                                                             :form-params {:Name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet"

	payload := strings.NewReader("{\n  \"Name\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "Name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet', [
  'body' => '{
  "Name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet"

payload = { "Name": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet"

payload <- "{\n  \"Name\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet";

    let payload = json!({"Name": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": ""
}'

echo '{
  "Name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["Name": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartFleet")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST StartImageBuilder

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder

HEADERS

X-Amz-Target

BODY json

{
  "Name": "",
  "AppstreamAgentVersion": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"AppstreamAgentVersion\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder" {:headers {:x-amz-target ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:Name ""
                                                                                                                  :AppstreamAgentVersion ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"AppstreamAgentVersion\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"AppstreamAgentVersion\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"AppstreamAgentVersion\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"AppstreamAgentVersion\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 47

{
  "Name": "",
  "AppstreamAgentVersion": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"AppstreamAgentVersion\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"AppstreamAgentVersion\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"AppstreamAgentVersion\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"AppstreamAgentVersion\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  AppstreamAgentVersion: ''
});

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=PhotonAdminProxyService.StartImageBuilder');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', AppstreamAgentVersion: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","AppstreamAgentVersion":""}'
};

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=PhotonAdminProxyService.StartImageBuilder',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "AppstreamAgentVersion": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"AppstreamAgentVersion\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Name: '', AppstreamAgentVersion: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: '', AppstreamAgentVersion: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: '',
  AppstreamAgentVersion: ''
});

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=PhotonAdminProxyService.StartImageBuilder',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', AppstreamAgentVersion: ''}
};

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=PhotonAdminProxyService.StartImageBuilder';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","AppstreamAgentVersion":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"AppstreamAgentVersion": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"AppstreamAgentVersion\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'AppstreamAgentVersion' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder', [
  'body' => '{
  "Name": "",
  "AppstreamAgentVersion": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'AppstreamAgentVersion' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => '',
  'AppstreamAgentVersion' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "AppstreamAgentVersion": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "AppstreamAgentVersion": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\",\n  \"AppstreamAgentVersion\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder"

payload = {
    "Name": "",
    "AppstreamAgentVersion": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder"

payload <- "{\n  \"Name\": \"\",\n  \"AppstreamAgentVersion\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"AppstreamAgentVersion\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\",\n  \"AppstreamAgentVersion\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder";

    let payload = json!({
        "Name": "",
        "AppstreamAgentVersion": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": "",
  "AppstreamAgentVersion": ""
}'

echo '{
  "Name": "",
  "AppstreamAgentVersion": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "AppstreamAgentVersion": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "AppstreamAgentVersion": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StartImageBuilder")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST StopFleet

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet

HEADERS

X-Amz-Target

BODY json

{
  "Name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet" {:headers {:x-amz-target ""}
                                                                                            :content-type :json
                                                                                            :form-params {:Name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet"

	payload := strings.NewReader("{\n  \"Name\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "Name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet', [
  'body' => '{
  "Name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet"

payload = { "Name": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet"

payload <- "{\n  \"Name\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet";

    let payload = json!({"Name": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": ""
}'

echo '{
  "Name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["Name": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopFleet")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST StopImageBuilder

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder

HEADERS

X-Amz-Target

BODY json

{
  "Name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder" {:headers {:x-amz-target ""}
                                                                                                   :content-type :json
                                                                                                   :form-params {:Name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder"

	payload := strings.NewReader("{\n  \"Name\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "Name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder', [
  'body' => '{
  "Name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder"

payload = { "Name": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder"

payload <- "{\n  \"Name\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder";

    let payload = json!({"Name": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": ""
}'

echo '{
  "Name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["Name": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.StopImageBuilder")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST TagResource

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource

HEADERS

X-Amz-Target

BODY json

{
  "ResourceArn": "",
  "Tags": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource" {:headers {:x-amz-target ""}
                                                                                              :content-type :json
                                                                                              :form-params {:ResourceArn ""
                                                                                                            :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource"

	payload := strings.NewReader("{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 37

{
  "ResourceArn": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ResourceArn: '',
  Tags: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: '', Tags: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":"","Tags":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ResourceArn": "",\n  "Tags": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({ResourceArn: '', Tags: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ResourceArn: '', Tags: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ResourceArn: '',
  Tags: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: '', Tags: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":"","Tags":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ResourceArn": @"",
                              @"Tags": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'ResourceArn' => '',
    'Tags' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource', [
  'body' => '{
  "ResourceArn": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ResourceArn' => '',
  'Tags' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ResourceArn' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceArn": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceArn": "",
  "Tags": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource"

payload = {
    "ResourceArn": "",
    "Tags": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource"

payload <- "{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource";

    let payload = json!({
        "ResourceArn": "",
        "Tags": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceArn": "",
  "Tags": ""
}'

echo '{
  "ResourceArn": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ResourceArn": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ResourceArn": "",
  "Tags": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.TagResource")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UntagResource

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource

HEADERS

X-Amz-Target

BODY json

{
  "ResourceArn": "",
  "TagKeys": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource" {:headers {:x-amz-target ""}
                                                                                                :content-type :json
                                                                                                :form-params {:ResourceArn ""
                                                                                                              :TagKeys ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource"

	payload := strings.NewReader("{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "ResourceArn": "",
  "TagKeys": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ResourceArn: '',
  TagKeys: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: '', TagKeys: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":"","TagKeys":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ResourceArn": "",\n  "TagKeys": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({ResourceArn: '', TagKeys: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ResourceArn: '', TagKeys: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ResourceArn: '',
  TagKeys: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: '', TagKeys: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":"","TagKeys":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ResourceArn": @"",
                              @"TagKeys": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'ResourceArn' => '',
    'TagKeys' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource', [
  'body' => '{
  "ResourceArn": "",
  "TagKeys": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ResourceArn' => '',
  'TagKeys' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ResourceArn' => '',
  'TagKeys' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceArn": "",
  "TagKeys": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceArn": "",
  "TagKeys": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource"

payload = {
    "ResourceArn": "",
    "TagKeys": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource"

payload <- "{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource";

    let payload = json!({
        "ResourceArn": "",
        "TagKeys": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceArn": "",
  "TagKeys": ""
}'

echo '{
  "ResourceArn": "",
  "TagKeys": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ResourceArn": "",\n  "TagKeys": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ResourceArn": "",
  "TagKeys": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UntagResource")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateApplication

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication

HEADERS

X-Amz-Target

BODY json

{
  "Name": "",
  "DisplayName": "",
  "Description": "",
  "IconS3Location": "",
  "LaunchPath": "",
  "WorkingDirectory": "",
  "LaunchParameters": "",
  "AppBlockArn": "",
  "AttributesToDelete": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"AppBlockArn\": \"\",\n  \"AttributesToDelete\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication" {:headers {:x-amz-target ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:Name ""
                                                                                                                  :DisplayName ""
                                                                                                                  :Description ""
                                                                                                                  :IconS3Location ""
                                                                                                                  :LaunchPath ""
                                                                                                                  :WorkingDirectory ""
                                                                                                                  :LaunchParameters ""
                                                                                                                  :AppBlockArn ""
                                                                                                                  :AttributesToDelete ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"AppBlockArn\": \"\",\n  \"AttributesToDelete\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"AppBlockArn\": \"\",\n  \"AttributesToDelete\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"AppBlockArn\": \"\",\n  \"AttributesToDelete\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"AppBlockArn\": \"\",\n  \"AttributesToDelete\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 203

{
  "Name": "",
  "DisplayName": "",
  "Description": "",
  "IconS3Location": "",
  "LaunchPath": "",
  "WorkingDirectory": "",
  "LaunchParameters": "",
  "AppBlockArn": "",
  "AttributesToDelete": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"AppBlockArn\": \"\",\n  \"AttributesToDelete\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"AppBlockArn\": \"\",\n  \"AttributesToDelete\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"AppBlockArn\": \"\",\n  \"AttributesToDelete\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"AppBlockArn\": \"\",\n  \"AttributesToDelete\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  DisplayName: '',
  Description: '',
  IconS3Location: '',
  LaunchPath: '',
  WorkingDirectory: '',
  LaunchParameters: '',
  AppBlockArn: '',
  AttributesToDelete: ''
});

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=PhotonAdminProxyService.UpdateApplication');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    DisplayName: '',
    Description: '',
    IconS3Location: '',
    LaunchPath: '',
    WorkingDirectory: '',
    LaunchParameters: '',
    AppBlockArn: '',
    AttributesToDelete: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","DisplayName":"","Description":"","IconS3Location":"","LaunchPath":"","WorkingDirectory":"","LaunchParameters":"","AppBlockArn":"","AttributesToDelete":""}'
};

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=PhotonAdminProxyService.UpdateApplication',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "DisplayName": "",\n  "Description": "",\n  "IconS3Location": "",\n  "LaunchPath": "",\n  "WorkingDirectory": "",\n  "LaunchParameters": "",\n  "AppBlockArn": "",\n  "AttributesToDelete": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"AppBlockArn\": \"\",\n  \"AttributesToDelete\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  Name: '',
  DisplayName: '',
  Description: '',
  IconS3Location: '',
  LaunchPath: '',
  WorkingDirectory: '',
  LaunchParameters: '',
  AppBlockArn: '',
  AttributesToDelete: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    Name: '',
    DisplayName: '',
    Description: '',
    IconS3Location: '',
    LaunchPath: '',
    WorkingDirectory: '',
    LaunchParameters: '',
    AppBlockArn: '',
    AttributesToDelete: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: '',
  DisplayName: '',
  Description: '',
  IconS3Location: '',
  LaunchPath: '',
  WorkingDirectory: '',
  LaunchParameters: '',
  AppBlockArn: '',
  AttributesToDelete: ''
});

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=PhotonAdminProxyService.UpdateApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    DisplayName: '',
    Description: '',
    IconS3Location: '',
    LaunchPath: '',
    WorkingDirectory: '',
    LaunchParameters: '',
    AppBlockArn: '',
    AttributesToDelete: ''
  }
};

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=PhotonAdminProxyService.UpdateApplication';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","DisplayName":"","Description":"","IconS3Location":"","LaunchPath":"","WorkingDirectory":"","LaunchParameters":"","AppBlockArn":"","AttributesToDelete":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"DisplayName": @"",
                              @"Description": @"",
                              @"IconS3Location": @"",
                              @"LaunchPath": @"",
                              @"WorkingDirectory": @"",
                              @"LaunchParameters": @"",
                              @"AppBlockArn": @"",
                              @"AttributesToDelete": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"AppBlockArn\": \"\",\n  \"AttributesToDelete\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'DisplayName' => '',
    'Description' => '',
    'IconS3Location' => '',
    'LaunchPath' => '',
    'WorkingDirectory' => '',
    'LaunchParameters' => '',
    'AppBlockArn' => '',
    'AttributesToDelete' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication', [
  'body' => '{
  "Name": "",
  "DisplayName": "",
  "Description": "",
  "IconS3Location": "",
  "LaunchPath": "",
  "WorkingDirectory": "",
  "LaunchParameters": "",
  "AppBlockArn": "",
  "AttributesToDelete": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'DisplayName' => '',
  'Description' => '',
  'IconS3Location' => '',
  'LaunchPath' => '',
  'WorkingDirectory' => '',
  'LaunchParameters' => '',
  'AppBlockArn' => '',
  'AttributesToDelete' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => '',
  'DisplayName' => '',
  'Description' => '',
  'IconS3Location' => '',
  'LaunchPath' => '',
  'WorkingDirectory' => '',
  'LaunchParameters' => '',
  'AppBlockArn' => '',
  'AttributesToDelete' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "DisplayName": "",
  "Description": "",
  "IconS3Location": "",
  "LaunchPath": "",
  "WorkingDirectory": "",
  "LaunchParameters": "",
  "AppBlockArn": "",
  "AttributesToDelete": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "DisplayName": "",
  "Description": "",
  "IconS3Location": "",
  "LaunchPath": "",
  "WorkingDirectory": "",
  "LaunchParameters": "",
  "AppBlockArn": "",
  "AttributesToDelete": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"AppBlockArn\": \"\",\n  \"AttributesToDelete\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication"

payload = {
    "Name": "",
    "DisplayName": "",
    "Description": "",
    "IconS3Location": "",
    "LaunchPath": "",
    "WorkingDirectory": "",
    "LaunchParameters": "",
    "AppBlockArn": "",
    "AttributesToDelete": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication"

payload <- "{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"AppBlockArn\": \"\",\n  \"AttributesToDelete\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"AppBlockArn\": \"\",\n  \"AttributesToDelete\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"IconS3Location\": \"\",\n  \"LaunchPath\": \"\",\n  \"WorkingDirectory\": \"\",\n  \"LaunchParameters\": \"\",\n  \"AppBlockArn\": \"\",\n  \"AttributesToDelete\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication";

    let payload = json!({
        "Name": "",
        "DisplayName": "",
        "Description": "",
        "IconS3Location": "",
        "LaunchPath": "",
        "WorkingDirectory": "",
        "LaunchParameters": "",
        "AppBlockArn": "",
        "AttributesToDelete": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": "",
  "DisplayName": "",
  "Description": "",
  "IconS3Location": "",
  "LaunchPath": "",
  "WorkingDirectory": "",
  "LaunchParameters": "",
  "AppBlockArn": "",
  "AttributesToDelete": ""
}'

echo '{
  "Name": "",
  "DisplayName": "",
  "Description": "",
  "IconS3Location": "",
  "LaunchPath": "",
  "WorkingDirectory": "",
  "LaunchParameters": "",
  "AppBlockArn": "",
  "AttributesToDelete": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "DisplayName": "",\n  "Description": "",\n  "IconS3Location": "",\n  "LaunchPath": "",\n  "WorkingDirectory": "",\n  "LaunchParameters": "",\n  "AppBlockArn": "",\n  "AttributesToDelete": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "DisplayName": "",
  "Description": "",
  "IconS3Location": "",
  "LaunchPath": "",
  "WorkingDirectory": "",
  "LaunchParameters": "",
  "AppBlockArn": "",
  "AttributesToDelete": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateApplication")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateDirectoryConfig

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig

HEADERS

X-Amz-Target

BODY json

{
  "DirectoryName": "",
  "OrganizationalUnitDistinguishedNames": "",
  "ServiceAccountCredentials": "",
  "CertificateBasedAuthProperties": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"DirectoryName\": \"\",\n  \"OrganizationalUnitDistinguishedNames\": \"\",\n  \"ServiceAccountCredentials\": \"\",\n  \"CertificateBasedAuthProperties\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:DirectoryName ""
                                                                                                                      :OrganizationalUnitDistinguishedNames ""
                                                                                                                      :ServiceAccountCredentials ""
                                                                                                                      :CertificateBasedAuthProperties ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"DirectoryName\": \"\",\n  \"OrganizationalUnitDistinguishedNames\": \"\",\n  \"ServiceAccountCredentials\": \"\",\n  \"CertificateBasedAuthProperties\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"DirectoryName\": \"\",\n  \"OrganizationalUnitDistinguishedNames\": \"\",\n  \"ServiceAccountCredentials\": \"\",\n  \"CertificateBasedAuthProperties\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DirectoryName\": \"\",\n  \"OrganizationalUnitDistinguishedNames\": \"\",\n  \"ServiceAccountCredentials\": \"\",\n  \"CertificateBasedAuthProperties\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig"

	payload := strings.NewReader("{\n  \"DirectoryName\": \"\",\n  \"OrganizationalUnitDistinguishedNames\": \"\",\n  \"ServiceAccountCredentials\": \"\",\n  \"CertificateBasedAuthProperties\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 146

{
  "DirectoryName": "",
  "OrganizationalUnitDistinguishedNames": "",
  "ServiceAccountCredentials": "",
  "CertificateBasedAuthProperties": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DirectoryName\": \"\",\n  \"OrganizationalUnitDistinguishedNames\": \"\",\n  \"ServiceAccountCredentials\": \"\",\n  \"CertificateBasedAuthProperties\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"DirectoryName\": \"\",\n  \"OrganizationalUnitDistinguishedNames\": \"\",\n  \"ServiceAccountCredentials\": \"\",\n  \"CertificateBasedAuthProperties\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"DirectoryName\": \"\",\n  \"OrganizationalUnitDistinguishedNames\": \"\",\n  \"ServiceAccountCredentials\": \"\",\n  \"CertificateBasedAuthProperties\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"DirectoryName\": \"\",\n  \"OrganizationalUnitDistinguishedNames\": \"\",\n  \"ServiceAccountCredentials\": \"\",\n  \"CertificateBasedAuthProperties\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  DirectoryName: '',
  OrganizationalUnitDistinguishedNames: '',
  ServiceAccountCredentials: '',
  CertificateBasedAuthProperties: ''
});

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=PhotonAdminProxyService.UpdateDirectoryConfig');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    DirectoryName: '',
    OrganizationalUnitDistinguishedNames: '',
    ServiceAccountCredentials: '',
    CertificateBasedAuthProperties: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DirectoryName":"","OrganizationalUnitDistinguishedNames":"","ServiceAccountCredentials":"","CertificateBasedAuthProperties":""}'
};

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=PhotonAdminProxyService.UpdateDirectoryConfig',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DirectoryName": "",\n  "OrganizationalUnitDistinguishedNames": "",\n  "ServiceAccountCredentials": "",\n  "CertificateBasedAuthProperties": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DirectoryName\": \"\",\n  \"OrganizationalUnitDistinguishedNames\": \"\",\n  \"ServiceAccountCredentials\": \"\",\n  \"CertificateBasedAuthProperties\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  DirectoryName: '',
  OrganizationalUnitDistinguishedNames: '',
  ServiceAccountCredentials: '',
  CertificateBasedAuthProperties: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    DirectoryName: '',
    OrganizationalUnitDistinguishedNames: '',
    ServiceAccountCredentials: '',
    CertificateBasedAuthProperties: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  DirectoryName: '',
  OrganizationalUnitDistinguishedNames: '',
  ServiceAccountCredentials: '',
  CertificateBasedAuthProperties: ''
});

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=PhotonAdminProxyService.UpdateDirectoryConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    DirectoryName: '',
    OrganizationalUnitDistinguishedNames: '',
    ServiceAccountCredentials: '',
    CertificateBasedAuthProperties: ''
  }
};

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=PhotonAdminProxyService.UpdateDirectoryConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DirectoryName":"","OrganizationalUnitDistinguishedNames":"","ServiceAccountCredentials":"","CertificateBasedAuthProperties":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"DirectoryName": @"",
                              @"OrganizationalUnitDistinguishedNames": @"",
                              @"ServiceAccountCredentials": @"",
                              @"CertificateBasedAuthProperties": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"DirectoryName\": \"\",\n  \"OrganizationalUnitDistinguishedNames\": \"\",\n  \"ServiceAccountCredentials\": \"\",\n  \"CertificateBasedAuthProperties\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'DirectoryName' => '',
    'OrganizationalUnitDistinguishedNames' => '',
    'ServiceAccountCredentials' => '',
    'CertificateBasedAuthProperties' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig', [
  'body' => '{
  "DirectoryName": "",
  "OrganizationalUnitDistinguishedNames": "",
  "ServiceAccountCredentials": "",
  "CertificateBasedAuthProperties": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DirectoryName' => '',
  'OrganizationalUnitDistinguishedNames' => '',
  'ServiceAccountCredentials' => '',
  'CertificateBasedAuthProperties' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'DirectoryName' => '',
  'OrganizationalUnitDistinguishedNames' => '',
  'ServiceAccountCredentials' => '',
  'CertificateBasedAuthProperties' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DirectoryName": "",
  "OrganizationalUnitDistinguishedNames": "",
  "ServiceAccountCredentials": "",
  "CertificateBasedAuthProperties": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DirectoryName": "",
  "OrganizationalUnitDistinguishedNames": "",
  "ServiceAccountCredentials": "",
  "CertificateBasedAuthProperties": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"DirectoryName\": \"\",\n  \"OrganizationalUnitDistinguishedNames\": \"\",\n  \"ServiceAccountCredentials\": \"\",\n  \"CertificateBasedAuthProperties\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig"

payload = {
    "DirectoryName": "",
    "OrganizationalUnitDistinguishedNames": "",
    "ServiceAccountCredentials": "",
    "CertificateBasedAuthProperties": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig"

payload <- "{\n  \"DirectoryName\": \"\",\n  \"OrganizationalUnitDistinguishedNames\": \"\",\n  \"ServiceAccountCredentials\": \"\",\n  \"CertificateBasedAuthProperties\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"DirectoryName\": \"\",\n  \"OrganizationalUnitDistinguishedNames\": \"\",\n  \"ServiceAccountCredentials\": \"\",\n  \"CertificateBasedAuthProperties\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"DirectoryName\": \"\",\n  \"OrganizationalUnitDistinguishedNames\": \"\",\n  \"ServiceAccountCredentials\": \"\",\n  \"CertificateBasedAuthProperties\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig";

    let payload = json!({
        "DirectoryName": "",
        "OrganizationalUnitDistinguishedNames": "",
        "ServiceAccountCredentials": "",
        "CertificateBasedAuthProperties": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "DirectoryName": "",
  "OrganizationalUnitDistinguishedNames": "",
  "ServiceAccountCredentials": "",
  "CertificateBasedAuthProperties": ""
}'

echo '{
  "DirectoryName": "",
  "OrganizationalUnitDistinguishedNames": "",
  "ServiceAccountCredentials": "",
  "CertificateBasedAuthProperties": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "DirectoryName": "",\n  "OrganizationalUnitDistinguishedNames": "",\n  "ServiceAccountCredentials": "",\n  "CertificateBasedAuthProperties": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "DirectoryName": "",
  "OrganizationalUnitDistinguishedNames": "",
  "ServiceAccountCredentials": "",
  "CertificateBasedAuthProperties": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateDirectoryConfig")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateEntitlement

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement

HEADERS

X-Amz-Target

BODY json

{
  "Name": "",
  "StackName": "",
  "Description": "",
  "AppVisibility": "",
  "Attributes": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"Description\": \"\",\n  \"AppVisibility\": \"\",\n  \"Attributes\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement" {:headers {:x-amz-target ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:Name ""
                                                                                                                  :StackName ""
                                                                                                                  :Description ""
                                                                                                                  :AppVisibility ""
                                                                                                                  :Attributes ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"Description\": \"\",\n  \"AppVisibility\": \"\",\n  \"Attributes\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"Description\": \"\",\n  \"AppVisibility\": \"\",\n  \"Attributes\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"Description\": \"\",\n  \"AppVisibility\": \"\",\n  \"Attributes\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"Description\": \"\",\n  \"AppVisibility\": \"\",\n  \"Attributes\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 99

{
  "Name": "",
  "StackName": "",
  "Description": "",
  "AppVisibility": "",
  "Attributes": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"Description\": \"\",\n  \"AppVisibility\": \"\",\n  \"Attributes\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"Description\": \"\",\n  \"AppVisibility\": \"\",\n  \"Attributes\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"Description\": \"\",\n  \"AppVisibility\": \"\",\n  \"Attributes\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"Description\": \"\",\n  \"AppVisibility\": \"\",\n  \"Attributes\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  StackName: '',
  Description: '',
  AppVisibility: '',
  Attributes: ''
});

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=PhotonAdminProxyService.UpdateEntitlement');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', StackName: '', Description: '', AppVisibility: '', Attributes: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","StackName":"","Description":"","AppVisibility":"","Attributes":""}'
};

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=PhotonAdminProxyService.UpdateEntitlement',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "StackName": "",\n  "Description": "",\n  "AppVisibility": "",\n  "Attributes": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"Description\": \"\",\n  \"AppVisibility\": \"\",\n  \"Attributes\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Name: '', StackName: '', Description: '', AppVisibility: '', Attributes: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: '', StackName: '', Description: '', AppVisibility: '', Attributes: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: '',
  StackName: '',
  Description: '',
  AppVisibility: '',
  Attributes: ''
});

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=PhotonAdminProxyService.UpdateEntitlement',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', StackName: '', Description: '', AppVisibility: '', Attributes: ''}
};

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=PhotonAdminProxyService.UpdateEntitlement';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","StackName":"","Description":"","AppVisibility":"","Attributes":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"StackName": @"",
                              @"Description": @"",
                              @"AppVisibility": @"",
                              @"Attributes": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"Description\": \"\",\n  \"AppVisibility\": \"\",\n  \"Attributes\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'StackName' => '',
    'Description' => '',
    'AppVisibility' => '',
    'Attributes' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement', [
  'body' => '{
  "Name": "",
  "StackName": "",
  "Description": "",
  "AppVisibility": "",
  "Attributes": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'StackName' => '',
  'Description' => '',
  'AppVisibility' => '',
  'Attributes' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => '',
  'StackName' => '',
  'Description' => '',
  'AppVisibility' => '',
  'Attributes' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "StackName": "",
  "Description": "",
  "AppVisibility": "",
  "Attributes": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "StackName": "",
  "Description": "",
  "AppVisibility": "",
  "Attributes": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"Description\": \"\",\n  \"AppVisibility\": \"\",\n  \"Attributes\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement"

payload = {
    "Name": "",
    "StackName": "",
    "Description": "",
    "AppVisibility": "",
    "Attributes": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement"

payload <- "{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"Description\": \"\",\n  \"AppVisibility\": \"\",\n  \"Attributes\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"Description\": \"\",\n  \"AppVisibility\": \"\",\n  \"Attributes\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\",\n  \"StackName\": \"\",\n  \"Description\": \"\",\n  \"AppVisibility\": \"\",\n  \"Attributes\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement";

    let payload = json!({
        "Name": "",
        "StackName": "",
        "Description": "",
        "AppVisibility": "",
        "Attributes": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": "",
  "StackName": "",
  "Description": "",
  "AppVisibility": "",
  "Attributes": ""
}'

echo '{
  "Name": "",
  "StackName": "",
  "Description": "",
  "AppVisibility": "",
  "Attributes": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "StackName": "",\n  "Description": "",\n  "AppVisibility": "",\n  "Attributes": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "StackName": "",
  "Description": "",
  "AppVisibility": "",
  "Attributes": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateEntitlement")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateFleet

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet

HEADERS

X-Amz-Target

BODY json

{
  "ImageName": "",
  "ImageArn": "",
  "Name": "",
  "InstanceType": "",
  "ComputeCapacity": "",
  "VpcConfig": "",
  "MaxUserDurationInSeconds": "",
  "DisconnectTimeoutInSeconds": "",
  "DeleteVpcConfig": "",
  "Description": "",
  "DisplayName": "",
  "EnableDefaultInternetAccess": "",
  "DomainJoinInfo": "",
  "IdleDisconnectTimeoutInSeconds": "",
  "AttributesToDelete": "",
  "IamRoleArn": "",
  "StreamView": "",
  "Platform": "",
  "MaxConcurrentSessions": "",
  "UsbDeviceFilterStrings": "",
  "SessionScriptS3Location": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"Name\": \"\",\n  \"InstanceType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"DeleteVpcConfig\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet" {:headers {:x-amz-target ""}
                                                                                              :content-type :json
                                                                                              :form-params {:ImageName ""
                                                                                                            :ImageArn ""
                                                                                                            :Name ""
                                                                                                            :InstanceType ""
                                                                                                            :ComputeCapacity ""
                                                                                                            :VpcConfig ""
                                                                                                            :MaxUserDurationInSeconds ""
                                                                                                            :DisconnectTimeoutInSeconds ""
                                                                                                            :DeleteVpcConfig ""
                                                                                                            :Description ""
                                                                                                            :DisplayName ""
                                                                                                            :EnableDefaultInternetAccess ""
                                                                                                            :DomainJoinInfo ""
                                                                                                            :IdleDisconnectTimeoutInSeconds ""
                                                                                                            :AttributesToDelete ""
                                                                                                            :IamRoleArn ""
                                                                                                            :StreamView ""
                                                                                                            :Platform ""
                                                                                                            :MaxConcurrentSessions ""
                                                                                                            :UsbDeviceFilterStrings ""
                                                                                                            :SessionScriptS3Location ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"Name\": \"\",\n  \"InstanceType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"DeleteVpcConfig\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"Name\": \"\",\n  \"InstanceType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"DeleteVpcConfig\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"Name\": \"\",\n  \"InstanceType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"DeleteVpcConfig\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet"

	payload := strings.NewReader("{\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"Name\": \"\",\n  \"InstanceType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"DeleteVpcConfig\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 539

{
  "ImageName": "",
  "ImageArn": "",
  "Name": "",
  "InstanceType": "",
  "ComputeCapacity": "",
  "VpcConfig": "",
  "MaxUserDurationInSeconds": "",
  "DisconnectTimeoutInSeconds": "",
  "DeleteVpcConfig": "",
  "Description": "",
  "DisplayName": "",
  "EnableDefaultInternetAccess": "",
  "DomainJoinInfo": "",
  "IdleDisconnectTimeoutInSeconds": "",
  "AttributesToDelete": "",
  "IamRoleArn": "",
  "StreamView": "",
  "Platform": "",
  "MaxConcurrentSessions": "",
  "UsbDeviceFilterStrings": "",
  "SessionScriptS3Location": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"Name\": \"\",\n  \"InstanceType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"DeleteVpcConfig\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"Name\": \"\",\n  \"InstanceType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"DeleteVpcConfig\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"Name\": \"\",\n  \"InstanceType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"DeleteVpcConfig\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"Name\": \"\",\n  \"InstanceType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"DeleteVpcConfig\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ImageName: '',
  ImageArn: '',
  Name: '',
  InstanceType: '',
  ComputeCapacity: '',
  VpcConfig: '',
  MaxUserDurationInSeconds: '',
  DisconnectTimeoutInSeconds: '',
  DeleteVpcConfig: '',
  Description: '',
  DisplayName: '',
  EnableDefaultInternetAccess: '',
  DomainJoinInfo: '',
  IdleDisconnectTimeoutInSeconds: '',
  AttributesToDelete: '',
  IamRoleArn: '',
  StreamView: '',
  Platform: '',
  MaxConcurrentSessions: '',
  UsbDeviceFilterStrings: '',
  SessionScriptS3Location: ''
});

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=PhotonAdminProxyService.UpdateFleet');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ImageName: '',
    ImageArn: '',
    Name: '',
    InstanceType: '',
    ComputeCapacity: '',
    VpcConfig: '',
    MaxUserDurationInSeconds: '',
    DisconnectTimeoutInSeconds: '',
    DeleteVpcConfig: '',
    Description: '',
    DisplayName: '',
    EnableDefaultInternetAccess: '',
    DomainJoinInfo: '',
    IdleDisconnectTimeoutInSeconds: '',
    AttributesToDelete: '',
    IamRoleArn: '',
    StreamView: '',
    Platform: '',
    MaxConcurrentSessions: '',
    UsbDeviceFilterStrings: '',
    SessionScriptS3Location: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ImageName":"","ImageArn":"","Name":"","InstanceType":"","ComputeCapacity":"","VpcConfig":"","MaxUserDurationInSeconds":"","DisconnectTimeoutInSeconds":"","DeleteVpcConfig":"","Description":"","DisplayName":"","EnableDefaultInternetAccess":"","DomainJoinInfo":"","IdleDisconnectTimeoutInSeconds":"","AttributesToDelete":"","IamRoleArn":"","StreamView":"","Platform":"","MaxConcurrentSessions":"","UsbDeviceFilterStrings":"","SessionScriptS3Location":""}'
};

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=PhotonAdminProxyService.UpdateFleet',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ImageName": "",\n  "ImageArn": "",\n  "Name": "",\n  "InstanceType": "",\n  "ComputeCapacity": "",\n  "VpcConfig": "",\n  "MaxUserDurationInSeconds": "",\n  "DisconnectTimeoutInSeconds": "",\n  "DeleteVpcConfig": "",\n  "Description": "",\n  "DisplayName": "",\n  "EnableDefaultInternetAccess": "",\n  "DomainJoinInfo": "",\n  "IdleDisconnectTimeoutInSeconds": "",\n  "AttributesToDelete": "",\n  "IamRoleArn": "",\n  "StreamView": "",\n  "Platform": "",\n  "MaxConcurrentSessions": "",\n  "UsbDeviceFilterStrings": "",\n  "SessionScriptS3Location": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"Name\": \"\",\n  \"InstanceType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"DeleteVpcConfig\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  ImageName: '',
  ImageArn: '',
  Name: '',
  InstanceType: '',
  ComputeCapacity: '',
  VpcConfig: '',
  MaxUserDurationInSeconds: '',
  DisconnectTimeoutInSeconds: '',
  DeleteVpcConfig: '',
  Description: '',
  DisplayName: '',
  EnableDefaultInternetAccess: '',
  DomainJoinInfo: '',
  IdleDisconnectTimeoutInSeconds: '',
  AttributesToDelete: '',
  IamRoleArn: '',
  StreamView: '',
  Platform: '',
  MaxConcurrentSessions: '',
  UsbDeviceFilterStrings: '',
  SessionScriptS3Location: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ImageName: '',
    ImageArn: '',
    Name: '',
    InstanceType: '',
    ComputeCapacity: '',
    VpcConfig: '',
    MaxUserDurationInSeconds: '',
    DisconnectTimeoutInSeconds: '',
    DeleteVpcConfig: '',
    Description: '',
    DisplayName: '',
    EnableDefaultInternetAccess: '',
    DomainJoinInfo: '',
    IdleDisconnectTimeoutInSeconds: '',
    AttributesToDelete: '',
    IamRoleArn: '',
    StreamView: '',
    Platform: '',
    MaxConcurrentSessions: '',
    UsbDeviceFilterStrings: '',
    SessionScriptS3Location: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ImageName: '',
  ImageArn: '',
  Name: '',
  InstanceType: '',
  ComputeCapacity: '',
  VpcConfig: '',
  MaxUserDurationInSeconds: '',
  DisconnectTimeoutInSeconds: '',
  DeleteVpcConfig: '',
  Description: '',
  DisplayName: '',
  EnableDefaultInternetAccess: '',
  DomainJoinInfo: '',
  IdleDisconnectTimeoutInSeconds: '',
  AttributesToDelete: '',
  IamRoleArn: '',
  StreamView: '',
  Platform: '',
  MaxConcurrentSessions: '',
  UsbDeviceFilterStrings: '',
  SessionScriptS3Location: ''
});

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=PhotonAdminProxyService.UpdateFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ImageName: '',
    ImageArn: '',
    Name: '',
    InstanceType: '',
    ComputeCapacity: '',
    VpcConfig: '',
    MaxUserDurationInSeconds: '',
    DisconnectTimeoutInSeconds: '',
    DeleteVpcConfig: '',
    Description: '',
    DisplayName: '',
    EnableDefaultInternetAccess: '',
    DomainJoinInfo: '',
    IdleDisconnectTimeoutInSeconds: '',
    AttributesToDelete: '',
    IamRoleArn: '',
    StreamView: '',
    Platform: '',
    MaxConcurrentSessions: '',
    UsbDeviceFilterStrings: '',
    SessionScriptS3Location: ''
  }
};

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=PhotonAdminProxyService.UpdateFleet';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ImageName":"","ImageArn":"","Name":"","InstanceType":"","ComputeCapacity":"","VpcConfig":"","MaxUserDurationInSeconds":"","DisconnectTimeoutInSeconds":"","DeleteVpcConfig":"","Description":"","DisplayName":"","EnableDefaultInternetAccess":"","DomainJoinInfo":"","IdleDisconnectTimeoutInSeconds":"","AttributesToDelete":"","IamRoleArn":"","StreamView":"","Platform":"","MaxConcurrentSessions":"","UsbDeviceFilterStrings":"","SessionScriptS3Location":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ImageName": @"",
                              @"ImageArn": @"",
                              @"Name": @"",
                              @"InstanceType": @"",
                              @"ComputeCapacity": @"",
                              @"VpcConfig": @"",
                              @"MaxUserDurationInSeconds": @"",
                              @"DisconnectTimeoutInSeconds": @"",
                              @"DeleteVpcConfig": @"",
                              @"Description": @"",
                              @"DisplayName": @"",
                              @"EnableDefaultInternetAccess": @"",
                              @"DomainJoinInfo": @"",
                              @"IdleDisconnectTimeoutInSeconds": @"",
                              @"AttributesToDelete": @"",
                              @"IamRoleArn": @"",
                              @"StreamView": @"",
                              @"Platform": @"",
                              @"MaxConcurrentSessions": @"",
                              @"UsbDeviceFilterStrings": @"",
                              @"SessionScriptS3Location": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"Name\": \"\",\n  \"InstanceType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"DeleteVpcConfig\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'ImageName' => '',
    'ImageArn' => '',
    'Name' => '',
    'InstanceType' => '',
    'ComputeCapacity' => '',
    'VpcConfig' => '',
    'MaxUserDurationInSeconds' => '',
    'DisconnectTimeoutInSeconds' => '',
    'DeleteVpcConfig' => '',
    'Description' => '',
    'DisplayName' => '',
    'EnableDefaultInternetAccess' => '',
    'DomainJoinInfo' => '',
    'IdleDisconnectTimeoutInSeconds' => '',
    'AttributesToDelete' => '',
    'IamRoleArn' => '',
    'StreamView' => '',
    'Platform' => '',
    'MaxConcurrentSessions' => '',
    'UsbDeviceFilterStrings' => '',
    'SessionScriptS3Location' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet', [
  'body' => '{
  "ImageName": "",
  "ImageArn": "",
  "Name": "",
  "InstanceType": "",
  "ComputeCapacity": "",
  "VpcConfig": "",
  "MaxUserDurationInSeconds": "",
  "DisconnectTimeoutInSeconds": "",
  "DeleteVpcConfig": "",
  "Description": "",
  "DisplayName": "",
  "EnableDefaultInternetAccess": "",
  "DomainJoinInfo": "",
  "IdleDisconnectTimeoutInSeconds": "",
  "AttributesToDelete": "",
  "IamRoleArn": "",
  "StreamView": "",
  "Platform": "",
  "MaxConcurrentSessions": "",
  "UsbDeviceFilterStrings": "",
  "SessionScriptS3Location": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ImageName' => '',
  'ImageArn' => '',
  'Name' => '',
  'InstanceType' => '',
  'ComputeCapacity' => '',
  'VpcConfig' => '',
  'MaxUserDurationInSeconds' => '',
  'DisconnectTimeoutInSeconds' => '',
  'DeleteVpcConfig' => '',
  'Description' => '',
  'DisplayName' => '',
  'EnableDefaultInternetAccess' => '',
  'DomainJoinInfo' => '',
  'IdleDisconnectTimeoutInSeconds' => '',
  'AttributesToDelete' => '',
  'IamRoleArn' => '',
  'StreamView' => '',
  'Platform' => '',
  'MaxConcurrentSessions' => '',
  'UsbDeviceFilterStrings' => '',
  'SessionScriptS3Location' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ImageName' => '',
  'ImageArn' => '',
  'Name' => '',
  'InstanceType' => '',
  'ComputeCapacity' => '',
  'VpcConfig' => '',
  'MaxUserDurationInSeconds' => '',
  'DisconnectTimeoutInSeconds' => '',
  'DeleteVpcConfig' => '',
  'Description' => '',
  'DisplayName' => '',
  'EnableDefaultInternetAccess' => '',
  'DomainJoinInfo' => '',
  'IdleDisconnectTimeoutInSeconds' => '',
  'AttributesToDelete' => '',
  'IamRoleArn' => '',
  'StreamView' => '',
  'Platform' => '',
  'MaxConcurrentSessions' => '',
  'UsbDeviceFilterStrings' => '',
  'SessionScriptS3Location' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ImageName": "",
  "ImageArn": "",
  "Name": "",
  "InstanceType": "",
  "ComputeCapacity": "",
  "VpcConfig": "",
  "MaxUserDurationInSeconds": "",
  "DisconnectTimeoutInSeconds": "",
  "DeleteVpcConfig": "",
  "Description": "",
  "DisplayName": "",
  "EnableDefaultInternetAccess": "",
  "DomainJoinInfo": "",
  "IdleDisconnectTimeoutInSeconds": "",
  "AttributesToDelete": "",
  "IamRoleArn": "",
  "StreamView": "",
  "Platform": "",
  "MaxConcurrentSessions": "",
  "UsbDeviceFilterStrings": "",
  "SessionScriptS3Location": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ImageName": "",
  "ImageArn": "",
  "Name": "",
  "InstanceType": "",
  "ComputeCapacity": "",
  "VpcConfig": "",
  "MaxUserDurationInSeconds": "",
  "DisconnectTimeoutInSeconds": "",
  "DeleteVpcConfig": "",
  "Description": "",
  "DisplayName": "",
  "EnableDefaultInternetAccess": "",
  "DomainJoinInfo": "",
  "IdleDisconnectTimeoutInSeconds": "",
  "AttributesToDelete": "",
  "IamRoleArn": "",
  "StreamView": "",
  "Platform": "",
  "MaxConcurrentSessions": "",
  "UsbDeviceFilterStrings": "",
  "SessionScriptS3Location": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"Name\": \"\",\n  \"InstanceType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"DeleteVpcConfig\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet"

payload = {
    "ImageName": "",
    "ImageArn": "",
    "Name": "",
    "InstanceType": "",
    "ComputeCapacity": "",
    "VpcConfig": "",
    "MaxUserDurationInSeconds": "",
    "DisconnectTimeoutInSeconds": "",
    "DeleteVpcConfig": "",
    "Description": "",
    "DisplayName": "",
    "EnableDefaultInternetAccess": "",
    "DomainJoinInfo": "",
    "IdleDisconnectTimeoutInSeconds": "",
    "AttributesToDelete": "",
    "IamRoleArn": "",
    "StreamView": "",
    "Platform": "",
    "MaxConcurrentSessions": "",
    "UsbDeviceFilterStrings": "",
    "SessionScriptS3Location": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet"

payload <- "{\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"Name\": \"\",\n  \"InstanceType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"DeleteVpcConfig\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"Name\": \"\",\n  \"InstanceType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"DeleteVpcConfig\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"ImageName\": \"\",\n  \"ImageArn\": \"\",\n  \"Name\": \"\",\n  \"InstanceType\": \"\",\n  \"ComputeCapacity\": \"\",\n  \"VpcConfig\": \"\",\n  \"MaxUserDurationInSeconds\": \"\",\n  \"DisconnectTimeoutInSeconds\": \"\",\n  \"DeleteVpcConfig\": \"\",\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"EnableDefaultInternetAccess\": \"\",\n  \"DomainJoinInfo\": \"\",\n  \"IdleDisconnectTimeoutInSeconds\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"IamRoleArn\": \"\",\n  \"StreamView\": \"\",\n  \"Platform\": \"\",\n  \"MaxConcurrentSessions\": \"\",\n  \"UsbDeviceFilterStrings\": \"\",\n  \"SessionScriptS3Location\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet";

    let payload = json!({
        "ImageName": "",
        "ImageArn": "",
        "Name": "",
        "InstanceType": "",
        "ComputeCapacity": "",
        "VpcConfig": "",
        "MaxUserDurationInSeconds": "",
        "DisconnectTimeoutInSeconds": "",
        "DeleteVpcConfig": "",
        "Description": "",
        "DisplayName": "",
        "EnableDefaultInternetAccess": "",
        "DomainJoinInfo": "",
        "IdleDisconnectTimeoutInSeconds": "",
        "AttributesToDelete": "",
        "IamRoleArn": "",
        "StreamView": "",
        "Platform": "",
        "MaxConcurrentSessions": "",
        "UsbDeviceFilterStrings": "",
        "SessionScriptS3Location": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ImageName": "",
  "ImageArn": "",
  "Name": "",
  "InstanceType": "",
  "ComputeCapacity": "",
  "VpcConfig": "",
  "MaxUserDurationInSeconds": "",
  "DisconnectTimeoutInSeconds": "",
  "DeleteVpcConfig": "",
  "Description": "",
  "DisplayName": "",
  "EnableDefaultInternetAccess": "",
  "DomainJoinInfo": "",
  "IdleDisconnectTimeoutInSeconds": "",
  "AttributesToDelete": "",
  "IamRoleArn": "",
  "StreamView": "",
  "Platform": "",
  "MaxConcurrentSessions": "",
  "UsbDeviceFilterStrings": "",
  "SessionScriptS3Location": ""
}'

echo '{
  "ImageName": "",
  "ImageArn": "",
  "Name": "",
  "InstanceType": "",
  "ComputeCapacity": "",
  "VpcConfig": "",
  "MaxUserDurationInSeconds": "",
  "DisconnectTimeoutInSeconds": "",
  "DeleteVpcConfig": "",
  "Description": "",
  "DisplayName": "",
  "EnableDefaultInternetAccess": "",
  "DomainJoinInfo": "",
  "IdleDisconnectTimeoutInSeconds": "",
  "AttributesToDelete": "",
  "IamRoleArn": "",
  "StreamView": "",
  "Platform": "",
  "MaxConcurrentSessions": "",
  "UsbDeviceFilterStrings": "",
  "SessionScriptS3Location": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ImageName": "",\n  "ImageArn": "",\n  "Name": "",\n  "InstanceType": "",\n  "ComputeCapacity": "",\n  "VpcConfig": "",\n  "MaxUserDurationInSeconds": "",\n  "DisconnectTimeoutInSeconds": "",\n  "DeleteVpcConfig": "",\n  "Description": "",\n  "DisplayName": "",\n  "EnableDefaultInternetAccess": "",\n  "DomainJoinInfo": "",\n  "IdleDisconnectTimeoutInSeconds": "",\n  "AttributesToDelete": "",\n  "IamRoleArn": "",\n  "StreamView": "",\n  "Platform": "",\n  "MaxConcurrentSessions": "",\n  "UsbDeviceFilterStrings": "",\n  "SessionScriptS3Location": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ImageName": "",
  "ImageArn": "",
  "Name": "",
  "InstanceType": "",
  "ComputeCapacity": "",
  "VpcConfig": "",
  "MaxUserDurationInSeconds": "",
  "DisconnectTimeoutInSeconds": "",
  "DeleteVpcConfig": "",
  "Description": "",
  "DisplayName": "",
  "EnableDefaultInternetAccess": "",
  "DomainJoinInfo": "",
  "IdleDisconnectTimeoutInSeconds": "",
  "AttributesToDelete": "",
  "IamRoleArn": "",
  "StreamView": "",
  "Platform": "",
  "MaxConcurrentSessions": "",
  "UsbDeviceFilterStrings": "",
  "SessionScriptS3Location": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateFleet")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateImagePermissions

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions

HEADERS

X-Amz-Target

BODY json

{
  "Name": "",
  "SharedAccountId": "",
  "ImagePermissions": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\",\n  \"ImagePermissions\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:Name ""
                                                                                                                       :SharedAccountId ""
                                                                                                                       :ImagePermissions ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\",\n  \"ImagePermissions\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\",\n  \"ImagePermissions\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\",\n  \"ImagePermissions\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\",\n  \"ImagePermissions\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 67

{
  "Name": "",
  "SharedAccountId": "",
  "ImagePermissions": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\",\n  \"ImagePermissions\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\",\n  \"ImagePermissions\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\",\n  \"ImagePermissions\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\",\n  \"ImagePermissions\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  SharedAccountId: '',
  ImagePermissions: ''
});

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=PhotonAdminProxyService.UpdateImagePermissions');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', SharedAccountId: '', ImagePermissions: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","SharedAccountId":"","ImagePermissions":""}'
};

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=PhotonAdminProxyService.UpdateImagePermissions',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "SharedAccountId": "",\n  "ImagePermissions": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\",\n  \"ImagePermissions\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Name: '', SharedAccountId: '', ImagePermissions: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: '', SharedAccountId: '', ImagePermissions: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: '',
  SharedAccountId: '',
  ImagePermissions: ''
});

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=PhotonAdminProxyService.UpdateImagePermissions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', SharedAccountId: '', ImagePermissions: ''}
};

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=PhotonAdminProxyService.UpdateImagePermissions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","SharedAccountId":"","ImagePermissions":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"SharedAccountId": @"",
                              @"ImagePermissions": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\",\n  \"ImagePermissions\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'SharedAccountId' => '',
    'ImagePermissions' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions', [
  'body' => '{
  "Name": "",
  "SharedAccountId": "",
  "ImagePermissions": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'SharedAccountId' => '',
  'ImagePermissions' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => '',
  'SharedAccountId' => '',
  'ImagePermissions' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "SharedAccountId": "",
  "ImagePermissions": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "SharedAccountId": "",
  "ImagePermissions": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\",\n  \"ImagePermissions\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions"

payload = {
    "Name": "",
    "SharedAccountId": "",
    "ImagePermissions": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions"

payload <- "{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\",\n  \"ImagePermissions\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\",\n  \"ImagePermissions\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\",\n  \"SharedAccountId\": \"\",\n  \"ImagePermissions\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions";

    let payload = json!({
        "Name": "",
        "SharedAccountId": "",
        "ImagePermissions": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": "",
  "SharedAccountId": "",
  "ImagePermissions": ""
}'

echo '{
  "Name": "",
  "SharedAccountId": "",
  "ImagePermissions": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "SharedAccountId": "",\n  "ImagePermissions": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "SharedAccountId": "",
  "ImagePermissions": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateImagePermissions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateStack

{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack

HEADERS

X-Amz-Target

BODY json

{
  "DisplayName": "",
  "Description": "",
  "Name": "",
  "StorageConnectors": "",
  "DeleteStorageConnectors": "",
  "RedirectURL": "",
  "FeedbackURL": "",
  "AttributesToDelete": "",
  "UserSettings": "",
  "ApplicationSettings": "",
  "AccessEndpoints": "",
  "EmbedHostDomains": "",
  "StreamingExperienceSettings": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"Name\": \"\",\n  \"StorageConnectors\": \"\",\n  \"DeleteStorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack" {:headers {:x-amz-target ""}
                                                                                              :content-type :json
                                                                                              :form-params {:DisplayName ""
                                                                                                            :Description ""
                                                                                                            :Name ""
                                                                                                            :StorageConnectors ""
                                                                                                            :DeleteStorageConnectors ""
                                                                                                            :RedirectURL ""
                                                                                                            :FeedbackURL ""
                                                                                                            :AttributesToDelete ""
                                                                                                            :UserSettings ""
                                                                                                            :ApplicationSettings ""
                                                                                                            :AccessEndpoints ""
                                                                                                            :EmbedHostDomains ""
                                                                                                            :StreamingExperienceSettings ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"Name\": \"\",\n  \"StorageConnectors\": \"\",\n  \"DeleteStorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"Name\": \"\",\n  \"StorageConnectors\": \"\",\n  \"DeleteStorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"Name\": \"\",\n  \"StorageConnectors\": \"\",\n  \"DeleteStorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack"

	payload := strings.NewReader("{\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"Name\": \"\",\n  \"StorageConnectors\": \"\",\n  \"DeleteStorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 327

{
  "DisplayName": "",
  "Description": "",
  "Name": "",
  "StorageConnectors": "",
  "DeleteStorageConnectors": "",
  "RedirectURL": "",
  "FeedbackURL": "",
  "AttributesToDelete": "",
  "UserSettings": "",
  "ApplicationSettings": "",
  "AccessEndpoints": "",
  "EmbedHostDomains": "",
  "StreamingExperienceSettings": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"Name\": \"\",\n  \"StorageConnectors\": \"\",\n  \"DeleteStorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"Name\": \"\",\n  \"StorageConnectors\": \"\",\n  \"DeleteStorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"Name\": \"\",\n  \"StorageConnectors\": \"\",\n  \"DeleteStorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"Name\": \"\",\n  \"StorageConnectors\": \"\",\n  \"DeleteStorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  DisplayName: '',
  Description: '',
  Name: '',
  StorageConnectors: '',
  DeleteStorageConnectors: '',
  RedirectURL: '',
  FeedbackURL: '',
  AttributesToDelete: '',
  UserSettings: '',
  ApplicationSettings: '',
  AccessEndpoints: '',
  EmbedHostDomains: '',
  StreamingExperienceSettings: ''
});

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=PhotonAdminProxyService.UpdateStack');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    DisplayName: '',
    Description: '',
    Name: '',
    StorageConnectors: '',
    DeleteStorageConnectors: '',
    RedirectURL: '',
    FeedbackURL: '',
    AttributesToDelete: '',
    UserSettings: '',
    ApplicationSettings: '',
    AccessEndpoints: '',
    EmbedHostDomains: '',
    StreamingExperienceSettings: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DisplayName":"","Description":"","Name":"","StorageConnectors":"","DeleteStorageConnectors":"","RedirectURL":"","FeedbackURL":"","AttributesToDelete":"","UserSettings":"","ApplicationSettings":"","AccessEndpoints":"","EmbedHostDomains":"","StreamingExperienceSettings":""}'
};

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=PhotonAdminProxyService.UpdateStack',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DisplayName": "",\n  "Description": "",\n  "Name": "",\n  "StorageConnectors": "",\n  "DeleteStorageConnectors": "",\n  "RedirectURL": "",\n  "FeedbackURL": "",\n  "AttributesToDelete": "",\n  "UserSettings": "",\n  "ApplicationSettings": "",\n  "AccessEndpoints": "",\n  "EmbedHostDomains": "",\n  "StreamingExperienceSettings": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"Name\": \"\",\n  \"StorageConnectors\": \"\",\n  \"DeleteStorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  DisplayName: '',
  Description: '',
  Name: '',
  StorageConnectors: '',
  DeleteStorageConnectors: '',
  RedirectURL: '',
  FeedbackURL: '',
  AttributesToDelete: '',
  UserSettings: '',
  ApplicationSettings: '',
  AccessEndpoints: '',
  EmbedHostDomains: '',
  StreamingExperienceSettings: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    DisplayName: '',
    Description: '',
    Name: '',
    StorageConnectors: '',
    DeleteStorageConnectors: '',
    RedirectURL: '',
    FeedbackURL: '',
    AttributesToDelete: '',
    UserSettings: '',
    ApplicationSettings: '',
    AccessEndpoints: '',
    EmbedHostDomains: '',
    StreamingExperienceSettings: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  DisplayName: '',
  Description: '',
  Name: '',
  StorageConnectors: '',
  DeleteStorageConnectors: '',
  RedirectURL: '',
  FeedbackURL: '',
  AttributesToDelete: '',
  UserSettings: '',
  ApplicationSettings: '',
  AccessEndpoints: '',
  EmbedHostDomains: '',
  StreamingExperienceSettings: ''
});

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=PhotonAdminProxyService.UpdateStack',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    DisplayName: '',
    Description: '',
    Name: '',
    StorageConnectors: '',
    DeleteStorageConnectors: '',
    RedirectURL: '',
    FeedbackURL: '',
    AttributesToDelete: '',
    UserSettings: '',
    ApplicationSettings: '',
    AccessEndpoints: '',
    EmbedHostDomains: '',
    StreamingExperienceSettings: ''
  }
};

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=PhotonAdminProxyService.UpdateStack';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DisplayName":"","Description":"","Name":"","StorageConnectors":"","DeleteStorageConnectors":"","RedirectURL":"","FeedbackURL":"","AttributesToDelete":"","UserSettings":"","ApplicationSettings":"","AccessEndpoints":"","EmbedHostDomains":"","StreamingExperienceSettings":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"DisplayName": @"",
                              @"Description": @"",
                              @"Name": @"",
                              @"StorageConnectors": @"",
                              @"DeleteStorageConnectors": @"",
                              @"RedirectURL": @"",
                              @"FeedbackURL": @"",
                              @"AttributesToDelete": @"",
                              @"UserSettings": @"",
                              @"ApplicationSettings": @"",
                              @"AccessEndpoints": @"",
                              @"EmbedHostDomains": @"",
                              @"StreamingExperienceSettings": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"Name\": \"\",\n  \"StorageConnectors\": \"\",\n  \"DeleteStorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'DisplayName' => '',
    'Description' => '',
    'Name' => '',
    'StorageConnectors' => '',
    'DeleteStorageConnectors' => '',
    'RedirectURL' => '',
    'FeedbackURL' => '',
    'AttributesToDelete' => '',
    'UserSettings' => '',
    'ApplicationSettings' => '',
    'AccessEndpoints' => '',
    'EmbedHostDomains' => '',
    'StreamingExperienceSettings' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack', [
  'body' => '{
  "DisplayName": "",
  "Description": "",
  "Name": "",
  "StorageConnectors": "",
  "DeleteStorageConnectors": "",
  "RedirectURL": "",
  "FeedbackURL": "",
  "AttributesToDelete": "",
  "UserSettings": "",
  "ApplicationSettings": "",
  "AccessEndpoints": "",
  "EmbedHostDomains": "",
  "StreamingExperienceSettings": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DisplayName' => '',
  'Description' => '',
  'Name' => '',
  'StorageConnectors' => '',
  'DeleteStorageConnectors' => '',
  'RedirectURL' => '',
  'FeedbackURL' => '',
  'AttributesToDelete' => '',
  'UserSettings' => '',
  'ApplicationSettings' => '',
  'AccessEndpoints' => '',
  'EmbedHostDomains' => '',
  'StreamingExperienceSettings' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'DisplayName' => '',
  'Description' => '',
  'Name' => '',
  'StorageConnectors' => '',
  'DeleteStorageConnectors' => '',
  'RedirectURL' => '',
  'FeedbackURL' => '',
  'AttributesToDelete' => '',
  'UserSettings' => '',
  'ApplicationSettings' => '',
  'AccessEndpoints' => '',
  'EmbedHostDomains' => '',
  'StreamingExperienceSettings' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DisplayName": "",
  "Description": "",
  "Name": "",
  "StorageConnectors": "",
  "DeleteStorageConnectors": "",
  "RedirectURL": "",
  "FeedbackURL": "",
  "AttributesToDelete": "",
  "UserSettings": "",
  "ApplicationSettings": "",
  "AccessEndpoints": "",
  "EmbedHostDomains": "",
  "StreamingExperienceSettings": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DisplayName": "",
  "Description": "",
  "Name": "",
  "StorageConnectors": "",
  "DeleteStorageConnectors": "",
  "RedirectURL": "",
  "FeedbackURL": "",
  "AttributesToDelete": "",
  "UserSettings": "",
  "ApplicationSettings": "",
  "AccessEndpoints": "",
  "EmbedHostDomains": "",
  "StreamingExperienceSettings": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"Name\": \"\",\n  \"StorageConnectors\": \"\",\n  \"DeleteStorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack"

payload = {
    "DisplayName": "",
    "Description": "",
    "Name": "",
    "StorageConnectors": "",
    "DeleteStorageConnectors": "",
    "RedirectURL": "",
    "FeedbackURL": "",
    "AttributesToDelete": "",
    "UserSettings": "",
    "ApplicationSettings": "",
    "AccessEndpoints": "",
    "EmbedHostDomains": "",
    "StreamingExperienceSettings": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack"

payload <- "{\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"Name\": \"\",\n  \"StorageConnectors\": \"\",\n  \"DeleteStorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"Name\": \"\",\n  \"StorageConnectors\": \"\",\n  \"DeleteStorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"Name\": \"\",\n  \"StorageConnectors\": \"\",\n  \"DeleteStorageConnectors\": \"\",\n  \"RedirectURL\": \"\",\n  \"FeedbackURL\": \"\",\n  \"AttributesToDelete\": \"\",\n  \"UserSettings\": \"\",\n  \"ApplicationSettings\": \"\",\n  \"AccessEndpoints\": \"\",\n  \"EmbedHostDomains\": \"\",\n  \"StreamingExperienceSettings\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack";

    let payload = json!({
        "DisplayName": "",
        "Description": "",
        "Name": "",
        "StorageConnectors": "",
        "DeleteStorageConnectors": "",
        "RedirectURL": "",
        "FeedbackURL": "",
        "AttributesToDelete": "",
        "UserSettings": "",
        "ApplicationSettings": "",
        "AccessEndpoints": "",
        "EmbedHostDomains": "",
        "StreamingExperienceSettings": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "DisplayName": "",
  "Description": "",
  "Name": "",
  "StorageConnectors": "",
  "DeleteStorageConnectors": "",
  "RedirectURL": "",
  "FeedbackURL": "",
  "AttributesToDelete": "",
  "UserSettings": "",
  "ApplicationSettings": "",
  "AccessEndpoints": "",
  "EmbedHostDomains": "",
  "StreamingExperienceSettings": ""
}'

echo '{
  "DisplayName": "",
  "Description": "",
  "Name": "",
  "StorageConnectors": "",
  "DeleteStorageConnectors": "",
  "RedirectURL": "",
  "FeedbackURL": "",
  "AttributesToDelete": "",
  "UserSettings": "",
  "ApplicationSettings": "",
  "AccessEndpoints": "",
  "EmbedHostDomains": "",
  "StreamingExperienceSettings": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "DisplayName": "",\n  "Description": "",\n  "Name": "",\n  "StorageConnectors": "",\n  "DeleteStorageConnectors": "",\n  "RedirectURL": "",\n  "FeedbackURL": "",\n  "AttributesToDelete": "",\n  "UserSettings": "",\n  "ApplicationSettings": "",\n  "AccessEndpoints": "",\n  "EmbedHostDomains": "",\n  "StreamingExperienceSettings": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "DisplayName": "",
  "Description": "",
  "Name": "",
  "StorageConnectors": "",
  "DeleteStorageConnectors": "",
  "RedirectURL": "",
  "FeedbackURL": "",
  "AttributesToDelete": "",
  "UserSettings": "",
  "ApplicationSettings": "",
  "AccessEndpoints": "",
  "EmbedHostDomains": "",
  "StreamingExperienceSettings": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=PhotonAdminProxyService.UpdateStack")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()