AWS Service Catalog

POST AcceptPortfolioShare

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AcceptPortfolioShare

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PortfolioShareType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PortfolioShareType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AcceptPortfolioShare" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:AcceptLanguage ""
                                                                                                                         :PortfolioId ""
                                                                                                                         :PortfolioShareType ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AcceptPortfolioShare"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PortfolioShareType\": \"\"\n}")

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

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

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

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

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

}

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

{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PortfolioShareType": ""
}

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

client.close();

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

const data = JSON.stringify({
  AcceptLanguage: '',
  PortfolioId: '',
  PortfolioShareType: ''
});

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=AWS242ServiceCatalogService.AcceptPortfolioShare');
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=AWS242ServiceCatalogService.AcceptPortfolioShare',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', PortfolioId: '', PortfolioShareType: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AcceptPortfolioShare';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PortfolioId":"","PortfolioShareType":""}'
};

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  AcceptLanguage: '',
  PortfolioId: '',
  PortfolioShareType: ''
});

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=AWS242ServiceCatalogService.AcceptPortfolioShare',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', PortfolioId: '', PortfolioShareType: ''}
};

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=AWS242ServiceCatalogService.AcceptPortfolioShare';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PortfolioId":"","PortfolioShareType":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"PortfolioId": @"",
                              @"PortfolioShareType": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'PortfolioId' => '',
  'PortfolioShareType' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PortfolioShareType\": \"\"\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=AWS242ServiceCatalogService.AcceptPortfolioShare"

payload = {
    "AcceptLanguage": "",
    "PortfolioId": "",
    "PortfolioShareType": ""
}
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=AWS242ServiceCatalogService.AcceptPortfolioShare"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PortfolioShareType\": \"\"\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=AWS242ServiceCatalogService.AcceptPortfolioShare")

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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PortfolioShareType\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PortfolioShareType\": \"\"\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=AWS242ServiceCatalogService.AcceptPortfolioShare";

    let payload = json!({
        "AcceptLanguage": "",
        "PortfolioId": "",
        "PortfolioShareType": ""
    });

    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=AWS242ServiceCatalogService.AcceptPortfolioShare' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PortfolioShareType": ""
}'

echo '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PortfolioShareType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AcceptPortfolioShare' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "PortfolioId": "",\n  "PortfolioShareType": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AcceptPortfolioShare'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AssociateBudgetWithResource

HEADERS

X-Amz-Target

BODY json

{
  "BudgetName": "",
  "ResourceId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AssociateBudgetWithResource" {:headers {:x-amz-target ""}
                                                                                                                  :content-type :json
                                                                                                                  :form-params {:BudgetName ""
                                                                                                                                :ResourceId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AssociateBudgetWithResource"

	payload := strings.NewReader("{\n  \"BudgetName\": \"\",\n  \"ResourceId\": \"\"\n}")

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

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

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

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

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

}

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

{
  "BudgetName": "",
  "ResourceId": ""
}

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

client.close();

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

const data = JSON.stringify({
  BudgetName: '',
  ResourceId: ''
});

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=AWS242ServiceCatalogService.AssociateBudgetWithResource');
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=AWS242ServiceCatalogService.AssociateBudgetWithResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {BudgetName: '', ResourceId: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  BudgetName: '',
  ResourceId: ''
});

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=AWS242ServiceCatalogService.AssociateBudgetWithResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {BudgetName: '', ResourceId: ''}
};

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"BudgetName\": \"\",\n  \"ResourceId\": \"\"\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=AWS242ServiceCatalogService.AssociateBudgetWithResource"

payload = {
    "BudgetName": "",
    "ResourceId": ""
}
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=AWS242ServiceCatalogService.AssociateBudgetWithResource"

payload <- "{\n  \"BudgetName\": \"\",\n  \"ResourceId\": \"\"\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=AWS242ServiceCatalogService.AssociateBudgetWithResource")

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  \"BudgetName\": \"\",\n  \"ResourceId\": \"\"\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  \"BudgetName\": \"\",\n  \"ResourceId\": \"\"\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=AWS242ServiceCatalogService.AssociateBudgetWithResource";

    let payload = json!({
        "BudgetName": "",
        "ResourceId": ""
    });

    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=AWS242ServiceCatalogService.AssociateBudgetWithResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "BudgetName": "",
  "ResourceId": ""
}'

echo '{
  "BudgetName": "",
  "ResourceId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AssociateBudgetWithResource' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AssociatePrincipalWithPortfolio

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PrincipalARN": "",
  "PrincipalType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PrincipalARN\": \"\",\n  \"PrincipalType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AssociatePrincipalWithPortfolio" {:headers {:x-amz-target ""}
                                                                                                                      :content-type :json
                                                                                                                      :form-params {:AcceptLanguage ""
                                                                                                                                    :PortfolioId ""
                                                                                                                                    :PrincipalARN ""
                                                                                                                                    :PrincipalType ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AssociatePrincipalWithPortfolio"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PrincipalARN\": \"\",\n  \"PrincipalType\": \"\"\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: 92

{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PrincipalARN": "",
  "PrincipalType": ""
}

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

client.close();

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

const data = JSON.stringify({
  AcceptLanguage: '',
  PortfolioId: '',
  PrincipalARN: '',
  PrincipalType: ''
});

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=AWS242ServiceCatalogService.AssociatePrincipalWithPortfolio');
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=AWS242ServiceCatalogService.AssociatePrincipalWithPortfolio',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', PortfolioId: '', PrincipalARN: '', PrincipalType: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AssociatePrincipalWithPortfolio';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PortfolioId":"","PrincipalARN":"","PrincipalType":""}'
};

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=AWS242ServiceCatalogService.AssociatePrincipalWithPortfolio',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "PortfolioId": "",\n  "PrincipalARN": "",\n  "PrincipalType": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  AcceptLanguage: '',
  PortfolioId: '',
  PrincipalARN: '',
  PrincipalType: ''
});

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=AWS242ServiceCatalogService.AssociatePrincipalWithPortfolio',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', PortfolioId: '', PrincipalARN: '', PrincipalType: ''}
};

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=AWS242ServiceCatalogService.AssociatePrincipalWithPortfolio';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PortfolioId":"","PrincipalARN":"","PrincipalType":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"PortfolioId": @"",
                              @"PrincipalARN": @"",
                              @"PrincipalType": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'PortfolioId' => '',
  'PrincipalARN' => '',
  'PrincipalType' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PrincipalARN\": \"\",\n  \"PrincipalType\": \"\"\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=AWS242ServiceCatalogService.AssociatePrincipalWithPortfolio"

payload = {
    "AcceptLanguage": "",
    "PortfolioId": "",
    "PrincipalARN": "",
    "PrincipalType": ""
}
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=AWS242ServiceCatalogService.AssociatePrincipalWithPortfolio"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PrincipalARN\": \"\",\n  \"PrincipalType\": \"\"\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=AWS242ServiceCatalogService.AssociatePrincipalWithPortfolio")

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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PrincipalARN\": \"\",\n  \"PrincipalType\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PrincipalARN\": \"\",\n  \"PrincipalType\": \"\"\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=AWS242ServiceCatalogService.AssociatePrincipalWithPortfolio";

    let payload = json!({
        "AcceptLanguage": "",
        "PortfolioId": "",
        "PrincipalARN": "",
        "PrincipalType": ""
    });

    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=AWS242ServiceCatalogService.AssociatePrincipalWithPortfolio' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PrincipalARN": "",
  "PrincipalType": ""
}'

echo '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PrincipalARN": "",
  "PrincipalType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AssociatePrincipalWithPortfolio' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "PortfolioId": "",\n  "PrincipalARN": "",\n  "PrincipalType": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AssociatePrincipalWithPortfolio'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AssociateProductWithPortfolio

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "ProductId": "",
  "PortfolioId": "",
  "SourcePortfolioId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PortfolioId\": \"\",\n  \"SourcePortfolioId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AssociateProductWithPortfolio" {:headers {:x-amz-target ""}
                                                                                                                    :content-type :json
                                                                                                                    :form-params {:AcceptLanguage ""
                                                                                                                                  :ProductId ""
                                                                                                                                  :PortfolioId ""
                                                                                                                                  :SourcePortfolioId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AssociateProductWithPortfolio"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PortfolioId\": \"\",\n  \"SourcePortfolioId\": \"\"\n}")

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

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

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

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

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

}

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

{
  "AcceptLanguage": "",
  "ProductId": "",
  "PortfolioId": "",
  "SourcePortfolioId": ""
}

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

client.close();

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

const data = JSON.stringify({
  AcceptLanguage: '',
  ProductId: '',
  PortfolioId: '',
  SourcePortfolioId: ''
});

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=AWS242ServiceCatalogService.AssociateProductWithPortfolio');
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=AWS242ServiceCatalogService.AssociateProductWithPortfolio',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', ProductId: '', PortfolioId: '', SourcePortfolioId: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AssociateProductWithPortfolio';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProductId":"","PortfolioId":"","SourcePortfolioId":""}'
};

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=AWS242ServiceCatalogService.AssociateProductWithPortfolio',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "ProductId": "",\n  "PortfolioId": "",\n  "SourcePortfolioId": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  AcceptLanguage: '',
  ProductId: '',
  PortfolioId: '',
  SourcePortfolioId: ''
});

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=AWS242ServiceCatalogService.AssociateProductWithPortfolio',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', ProductId: '', PortfolioId: '', SourcePortfolioId: ''}
};

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=AWS242ServiceCatalogService.AssociateProductWithPortfolio';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProductId":"","PortfolioId":"","SourcePortfolioId":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"ProductId": @"",
                              @"PortfolioId": @"",
                              @"SourcePortfolioId": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'ProductId' => '',
  'PortfolioId' => '',
  'SourcePortfolioId' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PortfolioId\": \"\",\n  \"SourcePortfolioId\": \"\"\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=AWS242ServiceCatalogService.AssociateProductWithPortfolio"

payload = {
    "AcceptLanguage": "",
    "ProductId": "",
    "PortfolioId": "",
    "SourcePortfolioId": ""
}
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=AWS242ServiceCatalogService.AssociateProductWithPortfolio"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PortfolioId\": \"\",\n  \"SourcePortfolioId\": \"\"\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=AWS242ServiceCatalogService.AssociateProductWithPortfolio")

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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PortfolioId\": \"\",\n  \"SourcePortfolioId\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PortfolioId\": \"\",\n  \"SourcePortfolioId\": \"\"\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=AWS242ServiceCatalogService.AssociateProductWithPortfolio";

    let payload = json!({
        "AcceptLanguage": "",
        "ProductId": "",
        "PortfolioId": "",
        "SourcePortfolioId": ""
    });

    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=AWS242ServiceCatalogService.AssociateProductWithPortfolio' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "ProductId": "",
  "PortfolioId": "",
  "SourcePortfolioId": ""
}'

echo '{
  "AcceptLanguage": "",
  "ProductId": "",
  "PortfolioId": "",
  "SourcePortfolioId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AssociateProductWithPortfolio' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "ProductId": "",\n  "PortfolioId": "",\n  "SourcePortfolioId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AssociateProductWithPortfolio'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AssociateServiceActionWithProvisioningArtifact

HEADERS

X-Amz-Target

BODY json

{
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "ServiceActionId": "",
  "AcceptLanguage": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AssociateServiceActionWithProvisioningArtifact" {:headers {:x-amz-target ""}
                                                                                                                                     :content-type :json
                                                                                                                                     :form-params {:ProductId ""
                                                                                                                                                   :ProvisioningArtifactId ""
                                                                                                                                                   :ServiceActionId ""
                                                                                                                                                   :AcceptLanguage ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AssociateServiceActionWithProvisioningArtifact"

	payload := strings.NewReader("{\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\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: 102

{
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "ServiceActionId": "",
  "AcceptLanguage": ""
}

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

client.close();

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

const data = JSON.stringify({
  ProductId: '',
  ProvisioningArtifactId: '',
  ServiceActionId: '',
  AcceptLanguage: ''
});

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=AWS242ServiceCatalogService.AssociateServiceActionWithProvisioningArtifact');
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=AWS242ServiceCatalogService.AssociateServiceActionWithProvisioningArtifact',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ProductId: '',
    ProvisioningArtifactId: '',
    ServiceActionId: '',
    AcceptLanguage: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AssociateServiceActionWithProvisioningArtifact';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ProductId":"","ProvisioningArtifactId":"","ServiceActionId":"","AcceptLanguage":""}'
};

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=AWS242ServiceCatalogService.AssociateServiceActionWithProvisioningArtifact',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ProductId": "",\n  "ProvisioningArtifactId": "",\n  "ServiceActionId": "",\n  "AcceptLanguage": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  ProductId: '',
  ProvisioningArtifactId: '',
  ServiceActionId: '',
  AcceptLanguage: ''
});

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=AWS242ServiceCatalogService.AssociateServiceActionWithProvisioningArtifact',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ProductId: '',
    ProvisioningArtifactId: '',
    ServiceActionId: '',
    AcceptLanguage: ''
  }
};

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=AWS242ServiceCatalogService.AssociateServiceActionWithProvisioningArtifact';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ProductId":"","ProvisioningArtifactId":"","ServiceActionId":"","AcceptLanguage":""}'
};

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 = @{ @"ProductId": @"",
                              @"ProvisioningArtifactId": @"",
                              @"ServiceActionId": @"",
                              @"AcceptLanguage": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ProductId' => '',
  'ProvisioningArtifactId' => '',
  'ServiceActionId' => '',
  'AcceptLanguage' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.AssociateServiceActionWithProvisioningArtifact"

payload = {
    "ProductId": "",
    "ProvisioningArtifactId": "",
    "ServiceActionId": "",
    "AcceptLanguage": ""
}
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=AWS242ServiceCatalogService.AssociateServiceActionWithProvisioningArtifact"

payload <- "{\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.AssociateServiceActionWithProvisioningArtifact")

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  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\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  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.AssociateServiceActionWithProvisioningArtifact";

    let payload = json!({
        "ProductId": "",
        "ProvisioningArtifactId": "",
        "ServiceActionId": "",
        "AcceptLanguage": ""
    });

    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=AWS242ServiceCatalogService.AssociateServiceActionWithProvisioningArtifact' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "ServiceActionId": "",
  "AcceptLanguage": ""
}'

echo '{
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "ServiceActionId": "",
  "AcceptLanguage": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AssociateServiceActionWithProvisioningArtifact' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ProductId": "",\n  "ProvisioningArtifactId": "",\n  "ServiceActionId": "",\n  "AcceptLanguage": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AssociateServiceActionWithProvisioningArtifact'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AssociateTagOptionWithResource

HEADERS

X-Amz-Target

BODY json

{
  "ResourceId": "",
  "TagOptionId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AssociateTagOptionWithResource" {:headers {:x-amz-target ""}
                                                                                                                     :content-type :json
                                                                                                                     :form-params {:ResourceId ""
                                                                                                                                   :TagOptionId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AssociateTagOptionWithResource"

	payload := strings.NewReader("{\n  \"ResourceId\": \"\",\n  \"TagOptionId\": \"\"\n}")

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

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

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

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

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

}

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

{
  "ResourceId": "",
  "TagOptionId": ""
}

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

client.close();

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

const data = JSON.stringify({
  ResourceId: '',
  TagOptionId: ''
});

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=AWS242ServiceCatalogService.AssociateTagOptionWithResource');
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=AWS242ServiceCatalogService.AssociateTagOptionWithResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceId: '', TagOptionId: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  ResourceId: '',
  TagOptionId: ''
});

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=AWS242ServiceCatalogService.AssociateTagOptionWithResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceId: '', TagOptionId: ''}
};

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"ResourceId\": \"\",\n  \"TagOptionId\": \"\"\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=AWS242ServiceCatalogService.AssociateTagOptionWithResource"

payload = {
    "ResourceId": "",
    "TagOptionId": ""
}
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=AWS242ServiceCatalogService.AssociateTagOptionWithResource"

payload <- "{\n  \"ResourceId\": \"\",\n  \"TagOptionId\": \"\"\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=AWS242ServiceCatalogService.AssociateTagOptionWithResource")

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  \"ResourceId\": \"\",\n  \"TagOptionId\": \"\"\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  \"ResourceId\": \"\",\n  \"TagOptionId\": \"\"\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=AWS242ServiceCatalogService.AssociateTagOptionWithResource";

    let payload = json!({
        "ResourceId": "",
        "TagOptionId": ""
    });

    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=AWS242ServiceCatalogService.AssociateTagOptionWithResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceId": "",
  "TagOptionId": ""
}'

echo '{
  "ResourceId": "",
  "TagOptionId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.AssociateTagOptionWithResource' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.BatchAssociateServiceActionWithProvisioningArtifact

HEADERS

X-Amz-Target

BODY json

{
  "ServiceActionAssociations": "",
  "AcceptLanguage": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.BatchAssociateServiceActionWithProvisioningArtifact" {:headers {:x-amz-target ""}
                                                                                                                                          :content-type :json
                                                                                                                                          :form-params {:ServiceActionAssociations ""
                                                                                                                                                        :AcceptLanguage ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.BatchAssociateServiceActionWithProvisioningArtifact"

	payload := strings.NewReader("{\n  \"ServiceActionAssociations\": \"\",\n  \"AcceptLanguage\": \"\"\n}")

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

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

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

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

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

}

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

{
  "ServiceActionAssociations": "",
  "AcceptLanguage": ""
}

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

client.close();

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

const data = JSON.stringify({
  ServiceActionAssociations: '',
  AcceptLanguage: ''
});

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=AWS242ServiceCatalogService.BatchAssociateServiceActionWithProvisioningArtifact');
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=AWS242ServiceCatalogService.BatchAssociateServiceActionWithProvisioningArtifact',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ServiceActionAssociations: '', AcceptLanguage: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  ServiceActionAssociations: '',
  AcceptLanguage: ''
});

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=AWS242ServiceCatalogService.BatchAssociateServiceActionWithProvisioningArtifact',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ServiceActionAssociations: '', AcceptLanguage: ''}
};

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"ServiceActionAssociations\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.BatchAssociateServiceActionWithProvisioningArtifact"

payload = {
    "ServiceActionAssociations": "",
    "AcceptLanguage": ""
}
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=AWS242ServiceCatalogService.BatchAssociateServiceActionWithProvisioningArtifact"

payload <- "{\n  \"ServiceActionAssociations\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.BatchAssociateServiceActionWithProvisioningArtifact")

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  \"ServiceActionAssociations\": \"\",\n  \"AcceptLanguage\": \"\"\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  \"ServiceActionAssociations\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.BatchAssociateServiceActionWithProvisioningArtifact";

    let payload = json!({
        "ServiceActionAssociations": "",
        "AcceptLanguage": ""
    });

    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=AWS242ServiceCatalogService.BatchAssociateServiceActionWithProvisioningArtifact' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ServiceActionAssociations": "",
  "AcceptLanguage": ""
}'

echo '{
  "ServiceActionAssociations": "",
  "AcceptLanguage": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.BatchAssociateServiceActionWithProvisioningArtifact' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.BatchDisassociateServiceActionFromProvisioningArtifact

HEADERS

X-Amz-Target

BODY json

{
  "ServiceActionAssociations": "",
  "AcceptLanguage": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.BatchDisassociateServiceActionFromProvisioningArtifact" {:headers {:x-amz-target ""}
                                                                                                                                             :content-type :json
                                                                                                                                             :form-params {:ServiceActionAssociations ""
                                                                                                                                                           :AcceptLanguage ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.BatchDisassociateServiceActionFromProvisioningArtifact"

	payload := strings.NewReader("{\n  \"ServiceActionAssociations\": \"\",\n  \"AcceptLanguage\": \"\"\n}")

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

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

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

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

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

}

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

{
  "ServiceActionAssociations": "",
  "AcceptLanguage": ""
}

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

client.close();

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

const data = JSON.stringify({
  ServiceActionAssociations: '',
  AcceptLanguage: ''
});

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=AWS242ServiceCatalogService.BatchDisassociateServiceActionFromProvisioningArtifact');
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=AWS242ServiceCatalogService.BatchDisassociateServiceActionFromProvisioningArtifact',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ServiceActionAssociations: '', AcceptLanguage: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  ServiceActionAssociations: '',
  AcceptLanguage: ''
});

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=AWS242ServiceCatalogService.BatchDisassociateServiceActionFromProvisioningArtifact',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ServiceActionAssociations: '', AcceptLanguage: ''}
};

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"ServiceActionAssociations\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.BatchDisassociateServiceActionFromProvisioningArtifact"

payload = {
    "ServiceActionAssociations": "",
    "AcceptLanguage": ""
}
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=AWS242ServiceCatalogService.BatchDisassociateServiceActionFromProvisioningArtifact"

payload <- "{\n  \"ServiceActionAssociations\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.BatchDisassociateServiceActionFromProvisioningArtifact")

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  \"ServiceActionAssociations\": \"\",\n  \"AcceptLanguage\": \"\"\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  \"ServiceActionAssociations\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.BatchDisassociateServiceActionFromProvisioningArtifact";

    let payload = json!({
        "ServiceActionAssociations": "",
        "AcceptLanguage": ""
    });

    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=AWS242ServiceCatalogService.BatchDisassociateServiceActionFromProvisioningArtifact' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ServiceActionAssociations": "",
  "AcceptLanguage": ""
}'

echo '{
  "ServiceActionAssociations": "",
  "AcceptLanguage": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.BatchDisassociateServiceActionFromProvisioningArtifact' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CopyProduct

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "SourceProductArn": "",
  "TargetProductId": "",
  "TargetProductName": "",
  "SourceProvisioningArtifactIdentifiers": "",
  "CopyOptions": "",
  "IdempotencyToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"AcceptLanguage\": \"\",\n  \"SourceProductArn\": \"\",\n  \"TargetProductId\": \"\",\n  \"TargetProductName\": \"\",\n  \"SourceProvisioningArtifactIdentifiers\": \"\",\n  \"CopyOptions\": \"\",\n  \"IdempotencyToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CopyProduct" {:headers {:x-amz-target ""}
                                                                                                  :content-type :json
                                                                                                  :form-params {:AcceptLanguage ""
                                                                                                                :SourceProductArn ""
                                                                                                                :TargetProductId ""
                                                                                                                :TargetProductName ""
                                                                                                                :SourceProvisioningArtifactIdentifiers ""
                                                                                                                :CopyOptions ""
                                                                                                                :IdempotencyToken ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CopyProduct"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"SourceProductArn\": \"\",\n  \"TargetProductId\": \"\",\n  \"TargetProductName\": \"\",\n  \"SourceProvisioningArtifactIdentifiers\": \"\",\n  \"CopyOptions\": \"\",\n  \"IdempotencyToken\": \"\"\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: 198

{
  "AcceptLanguage": "",
  "SourceProductArn": "",
  "TargetProductId": "",
  "TargetProductName": "",
  "SourceProvisioningArtifactIdentifiers": "",
  "CopyOptions": "",
  "IdempotencyToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CopyProduct")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"SourceProductArn\": \"\",\n  \"TargetProductId\": \"\",\n  \"TargetProductName\": \"\",\n  \"SourceProvisioningArtifactIdentifiers\": \"\",\n  \"CopyOptions\": \"\",\n  \"IdempotencyToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

const data = JSON.stringify({
  AcceptLanguage: '',
  SourceProductArn: '',
  TargetProductId: '',
  TargetProductName: '',
  SourceProvisioningArtifactIdentifiers: '',
  CopyOptions: '',
  IdempotencyToken: ''
});

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=AWS242ServiceCatalogService.CopyProduct');
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=AWS242ServiceCatalogService.CopyProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    SourceProductArn: '',
    TargetProductId: '',
    TargetProductName: '',
    SourceProvisioningArtifactIdentifiers: '',
    CopyOptions: '',
    IdempotencyToken: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CopyProduct';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","SourceProductArn":"","TargetProductId":"","TargetProductName":"","SourceProvisioningArtifactIdentifiers":"","CopyOptions":"","IdempotencyToken":""}'
};

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=AWS242ServiceCatalogService.CopyProduct',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "SourceProductArn": "",\n  "TargetProductId": "",\n  "TargetProductName": "",\n  "SourceProvisioningArtifactIdentifiers": "",\n  "CopyOptions": "",\n  "IdempotencyToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"SourceProductArn\": \"\",\n  \"TargetProductId\": \"\",\n  \"TargetProductName\": \"\",\n  \"SourceProvisioningArtifactIdentifiers\": \"\",\n  \"CopyOptions\": \"\",\n  \"IdempotencyToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CopyProduct")
  .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({
  AcceptLanguage: '',
  SourceProductArn: '',
  TargetProductId: '',
  TargetProductName: '',
  SourceProvisioningArtifactIdentifiers: '',
  CopyOptions: '',
  IdempotencyToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CopyProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AcceptLanguage: '',
    SourceProductArn: '',
    TargetProductId: '',
    TargetProductName: '',
    SourceProvisioningArtifactIdentifiers: '',
    CopyOptions: '',
    IdempotencyToken: ''
  },
  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=AWS242ServiceCatalogService.CopyProduct');

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

req.type('json');
req.send({
  AcceptLanguage: '',
  SourceProductArn: '',
  TargetProductId: '',
  TargetProductName: '',
  SourceProvisioningArtifactIdentifiers: '',
  CopyOptions: '',
  IdempotencyToken: ''
});

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=AWS242ServiceCatalogService.CopyProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    SourceProductArn: '',
    TargetProductId: '',
    TargetProductName: '',
    SourceProvisioningArtifactIdentifiers: '',
    CopyOptions: '',
    IdempotencyToken: ''
  }
};

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=AWS242ServiceCatalogService.CopyProduct';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","SourceProductArn":"","TargetProductId":"","TargetProductName":"","SourceProvisioningArtifactIdentifiers":"","CopyOptions":"","IdempotencyToken":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"SourceProductArn": @"",
                              @"TargetProductId": @"",
                              @"TargetProductName": @"",
                              @"SourceProvisioningArtifactIdentifiers": @"",
                              @"CopyOptions": @"",
                              @"IdempotencyToken": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CopyProduct",
  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([
    'AcceptLanguage' => '',
    'SourceProductArn' => '',
    'TargetProductId' => '',
    'TargetProductName' => '',
    'SourceProvisioningArtifactIdentifiers' => '',
    'CopyOptions' => '',
    'IdempotencyToken' => ''
  ]),
  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=AWS242ServiceCatalogService.CopyProduct', [
  'body' => '{
  "AcceptLanguage": "",
  "SourceProductArn": "",
  "TargetProductId": "",
  "TargetProductName": "",
  "SourceProvisioningArtifactIdentifiers": "",
  "CopyOptions": "",
  "IdempotencyToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'SourceProductArn' => '',
  'TargetProductId' => '',
  'TargetProductName' => '',
  'SourceProvisioningArtifactIdentifiers' => '',
  'CopyOptions' => '',
  'IdempotencyToken' => ''
]));

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

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

append(json_encode([
  'AcceptLanguage' => '',
  'SourceProductArn' => '',
  'TargetProductId' => '',
  'TargetProductName' => '',
  'SourceProvisioningArtifactIdentifiers' => '',
  'CopyOptions' => '',
  'IdempotencyToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CopyProduct');
$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=AWS242ServiceCatalogService.CopyProduct' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "SourceProductArn": "",
  "TargetProductId": "",
  "TargetProductName": "",
  "SourceProvisioningArtifactIdentifiers": "",
  "CopyOptions": "",
  "IdempotencyToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CopyProduct' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "SourceProductArn": "",
  "TargetProductId": "",
  "TargetProductName": "",
  "SourceProvisioningArtifactIdentifiers": "",
  "CopyOptions": "",
  "IdempotencyToken": ""
}'

import http.client

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

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"SourceProductArn\": \"\",\n  \"TargetProductId\": \"\",\n  \"TargetProductName\": \"\",\n  \"SourceProvisioningArtifactIdentifiers\": \"\",\n  \"CopyOptions\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.CopyProduct"

payload = {
    "AcceptLanguage": "",
    "SourceProductArn": "",
    "TargetProductId": "",
    "TargetProductName": "",
    "SourceProvisioningArtifactIdentifiers": "",
    "CopyOptions": "",
    "IdempotencyToken": ""
}
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=AWS242ServiceCatalogService.CopyProduct"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"SourceProductArn\": \"\",\n  \"TargetProductId\": \"\",\n  \"TargetProductName\": \"\",\n  \"SourceProvisioningArtifactIdentifiers\": \"\",\n  \"CopyOptions\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.CopyProduct")

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  \"AcceptLanguage\": \"\",\n  \"SourceProductArn\": \"\",\n  \"TargetProductId\": \"\",\n  \"TargetProductName\": \"\",\n  \"SourceProvisioningArtifactIdentifiers\": \"\",\n  \"CopyOptions\": \"\",\n  \"IdempotencyToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"SourceProductArn\": \"\",\n  \"TargetProductId\": \"\",\n  \"TargetProductName\": \"\",\n  \"SourceProvisioningArtifactIdentifiers\": \"\",\n  \"CopyOptions\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.CopyProduct";

    let payload = json!({
        "AcceptLanguage": "",
        "SourceProductArn": "",
        "TargetProductId": "",
        "TargetProductName": "",
        "SourceProvisioningArtifactIdentifiers": "",
        "CopyOptions": "",
        "IdempotencyToken": ""
    });

    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=AWS242ServiceCatalogService.CopyProduct' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "SourceProductArn": "",
  "TargetProductId": "",
  "TargetProductName": "",
  "SourceProvisioningArtifactIdentifiers": "",
  "CopyOptions": "",
  "IdempotencyToken": ""
}'

echo '{
  "AcceptLanguage": "",
  "SourceProductArn": "",
  "TargetProductId": "",
  "TargetProductName": "",
  "SourceProvisioningArtifactIdentifiers": "",
  "CopyOptions": "",
  "IdempotencyToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CopyProduct' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "SourceProductArn": "",\n  "TargetProductId": "",\n  "TargetProductName": "",\n  "SourceProvisioningArtifactIdentifiers": "",\n  "CopyOptions": "",\n  "IdempotencyToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CopyProduct'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "SourceProductArn": "",
  "TargetProductId": "",
  "TargetProductName": "",
  "SourceProvisioningArtifactIdentifiers": "",
  "CopyOptions": "",
  "IdempotencyToken": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateConstraint

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "ProductId": "",
  "Parameters": "",
  "Type": "",
  "Description": "",
  "IdempotencyToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"ProductId\": \"\",\n  \"Parameters\": \"\",\n  \"Type\": \"\",\n  \"Description\": \"\",\n  \"IdempotencyToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateConstraint" {:headers {:x-amz-target ""}
                                                                                                       :content-type :json
                                                                                                       :form-params {:AcceptLanguage ""
                                                                                                                     :PortfolioId ""
                                                                                                                     :ProductId ""
                                                                                                                     :Parameters ""
                                                                                                                     :Type ""
                                                                                                                     :Description ""
                                                                                                                     :IdempotencyToken ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateConstraint"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"ProductId\": \"\",\n  \"Parameters\": \"\",\n  \"Type\": \"\",\n  \"Description\": \"\",\n  \"IdempotencyToken\": \"\"\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

{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "ProductId": "",
  "Parameters": "",
  "Type": "",
  "Description": "",
  "IdempotencyToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateConstraint")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"ProductId\": \"\",\n  \"Parameters\": \"\",\n  \"Type\": \"\",\n  \"Description\": \"\",\n  \"IdempotencyToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

const data = JSON.stringify({
  AcceptLanguage: '',
  PortfolioId: '',
  ProductId: '',
  Parameters: '',
  Type: '',
  Description: '',
  IdempotencyToken: ''
});

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=AWS242ServiceCatalogService.CreateConstraint');
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=AWS242ServiceCatalogService.CreateConstraint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    PortfolioId: '',
    ProductId: '',
    Parameters: '',
    Type: '',
    Description: '',
    IdempotencyToken: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateConstraint';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PortfolioId":"","ProductId":"","Parameters":"","Type":"","Description":"","IdempotencyToken":""}'
};

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=AWS242ServiceCatalogService.CreateConstraint',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "PortfolioId": "",\n  "ProductId": "",\n  "Parameters": "",\n  "Type": "",\n  "Description": "",\n  "IdempotencyToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"ProductId\": \"\",\n  \"Parameters\": \"\",\n  \"Type\": \"\",\n  \"Description\": \"\",\n  \"IdempotencyToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateConstraint")
  .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({
  AcceptLanguage: '',
  PortfolioId: '',
  ProductId: '',
  Parameters: '',
  Type: '',
  Description: '',
  IdempotencyToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateConstraint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AcceptLanguage: '',
    PortfolioId: '',
    ProductId: '',
    Parameters: '',
    Type: '',
    Description: '',
    IdempotencyToken: ''
  },
  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=AWS242ServiceCatalogService.CreateConstraint');

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

req.type('json');
req.send({
  AcceptLanguage: '',
  PortfolioId: '',
  ProductId: '',
  Parameters: '',
  Type: '',
  Description: '',
  IdempotencyToken: ''
});

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=AWS242ServiceCatalogService.CreateConstraint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    PortfolioId: '',
    ProductId: '',
    Parameters: '',
    Type: '',
    Description: '',
    IdempotencyToken: ''
  }
};

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=AWS242ServiceCatalogService.CreateConstraint';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PortfolioId":"","ProductId":"","Parameters":"","Type":"","Description":"","IdempotencyToken":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"PortfolioId": @"",
                              @"ProductId": @"",
                              @"Parameters": @"",
                              @"Type": @"",
                              @"Description": @"",
                              @"IdempotencyToken": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateConstraint",
  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([
    'AcceptLanguage' => '',
    'PortfolioId' => '',
    'ProductId' => '',
    'Parameters' => '',
    'Type' => '',
    'Description' => '',
    'IdempotencyToken' => ''
  ]),
  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=AWS242ServiceCatalogService.CreateConstraint', [
  'body' => '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "ProductId": "",
  "Parameters": "",
  "Type": "",
  "Description": "",
  "IdempotencyToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'PortfolioId' => '',
  'ProductId' => '',
  'Parameters' => '',
  'Type' => '',
  'Description' => '',
  'IdempotencyToken' => ''
]));

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

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

append(json_encode([
  'AcceptLanguage' => '',
  'PortfolioId' => '',
  'ProductId' => '',
  'Parameters' => '',
  'Type' => '',
  'Description' => '',
  'IdempotencyToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateConstraint');
$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=AWS242ServiceCatalogService.CreateConstraint' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "ProductId": "",
  "Parameters": "",
  "Type": "",
  "Description": "",
  "IdempotencyToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateConstraint' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "ProductId": "",
  "Parameters": "",
  "Type": "",
  "Description": "",
  "IdempotencyToken": ""
}'

import http.client

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

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"ProductId\": \"\",\n  \"Parameters\": \"\",\n  \"Type\": \"\",\n  \"Description\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.CreateConstraint"

payload = {
    "AcceptLanguage": "",
    "PortfolioId": "",
    "ProductId": "",
    "Parameters": "",
    "Type": "",
    "Description": "",
    "IdempotencyToken": ""
}
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=AWS242ServiceCatalogService.CreateConstraint"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"ProductId\": \"\",\n  \"Parameters\": \"\",\n  \"Type\": \"\",\n  \"Description\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.CreateConstraint")

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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"ProductId\": \"\",\n  \"Parameters\": \"\",\n  \"Type\": \"\",\n  \"Description\": \"\",\n  \"IdempotencyToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"ProductId\": \"\",\n  \"Parameters\": \"\",\n  \"Type\": \"\",\n  \"Description\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.CreateConstraint";

    let payload = json!({
        "AcceptLanguage": "",
        "PortfolioId": "",
        "ProductId": "",
        "Parameters": "",
        "Type": "",
        "Description": "",
        "IdempotencyToken": ""
    });

    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=AWS242ServiceCatalogService.CreateConstraint' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "ProductId": "",
  "Parameters": "",
  "Type": "",
  "Description": "",
  "IdempotencyToken": ""
}'

echo '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "ProductId": "",
  "Parameters": "",
  "Type": "",
  "Description": "",
  "IdempotencyToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateConstraint' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "PortfolioId": "",\n  "ProductId": "",\n  "Parameters": "",\n  "Type": "",\n  "Description": "",\n  "IdempotencyToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateConstraint'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "PortfolioId": "",
  "ProductId": "",
  "Parameters": "",
  "Type": "",
  "Description": "",
  "IdempotencyToken": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreatePortfolio

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "DisplayName": "",
  "Description": "",
  "ProviderName": "",
  "Tags": "",
  "IdempotencyToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"AcceptLanguage\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"ProviderName\": \"\",\n  \"Tags\": \"\",\n  \"IdempotencyToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreatePortfolio" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:AcceptLanguage ""
                                                                                                                    :DisplayName ""
                                                                                                                    :Description ""
                                                                                                                    :ProviderName ""
                                                                                                                    :Tags ""
                                                                                                                    :IdempotencyToken ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreatePortfolio"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"ProviderName\": \"\",\n  \"Tags\": \"\",\n  \"IdempotencyToken\": \"\"\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: 130

{
  "AcceptLanguage": "",
  "DisplayName": "",
  "Description": "",
  "ProviderName": "",
  "Tags": "",
  "IdempotencyToken": ""
}

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

client.close();

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

const data = JSON.stringify({
  AcceptLanguage: '',
  DisplayName: '',
  Description: '',
  ProviderName: '',
  Tags: '',
  IdempotencyToken: ''
});

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=AWS242ServiceCatalogService.CreatePortfolio');
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=AWS242ServiceCatalogService.CreatePortfolio',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    DisplayName: '',
    Description: '',
    ProviderName: '',
    Tags: '',
    IdempotencyToken: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreatePortfolio';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","DisplayName":"","Description":"","ProviderName":"","Tags":"","IdempotencyToken":""}'
};

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=AWS242ServiceCatalogService.CreatePortfolio',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "DisplayName": "",\n  "Description": "",\n  "ProviderName": "",\n  "Tags": "",\n  "IdempotencyToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"ProviderName\": \"\",\n  \"Tags\": \"\",\n  \"IdempotencyToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreatePortfolio")
  .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({
  AcceptLanguage: '',
  DisplayName: '',
  Description: '',
  ProviderName: '',
  Tags: '',
  IdempotencyToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreatePortfolio',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AcceptLanguage: '',
    DisplayName: '',
    Description: '',
    ProviderName: '',
    Tags: '',
    IdempotencyToken: ''
  },
  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=AWS242ServiceCatalogService.CreatePortfolio');

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

req.type('json');
req.send({
  AcceptLanguage: '',
  DisplayName: '',
  Description: '',
  ProviderName: '',
  Tags: '',
  IdempotencyToken: ''
});

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=AWS242ServiceCatalogService.CreatePortfolio',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    DisplayName: '',
    Description: '',
    ProviderName: '',
    Tags: '',
    IdempotencyToken: ''
  }
};

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=AWS242ServiceCatalogService.CreatePortfolio';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","DisplayName":"","Description":"","ProviderName":"","Tags":"","IdempotencyToken":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"DisplayName": @"",
                              @"Description": @"",
                              @"ProviderName": @"",
                              @"Tags": @"",
                              @"IdempotencyToken": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreatePortfolio",
  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([
    'AcceptLanguage' => '',
    'DisplayName' => '',
    'Description' => '',
    'ProviderName' => '',
    'Tags' => '',
    'IdempotencyToken' => ''
  ]),
  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=AWS242ServiceCatalogService.CreatePortfolio', [
  'body' => '{
  "AcceptLanguage": "",
  "DisplayName": "",
  "Description": "",
  "ProviderName": "",
  "Tags": "",
  "IdempotencyToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'DisplayName' => '',
  'Description' => '',
  'ProviderName' => '',
  'Tags' => '',
  'IdempotencyToken' => ''
]));

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

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

append(json_encode([
  'AcceptLanguage' => '',
  'DisplayName' => '',
  'Description' => '',
  'ProviderName' => '',
  'Tags' => '',
  'IdempotencyToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreatePortfolio');
$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=AWS242ServiceCatalogService.CreatePortfolio' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "DisplayName": "",
  "Description": "",
  "ProviderName": "",
  "Tags": "",
  "IdempotencyToken": ""
}'

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

import http.client

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

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"ProviderName\": \"\",\n  \"Tags\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.CreatePortfolio"

payload = {
    "AcceptLanguage": "",
    "DisplayName": "",
    "Description": "",
    "ProviderName": "",
    "Tags": "",
    "IdempotencyToken": ""
}
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=AWS242ServiceCatalogService.CreatePortfolio"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"ProviderName\": \"\",\n  \"Tags\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.CreatePortfolio")

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  \"AcceptLanguage\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"ProviderName\": \"\",\n  \"Tags\": \"\",\n  \"IdempotencyToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"ProviderName\": \"\",\n  \"Tags\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.CreatePortfolio";

    let payload = json!({
        "AcceptLanguage": "",
        "DisplayName": "",
        "Description": "",
        "ProviderName": "",
        "Tags": "",
        "IdempotencyToken": ""
    });

    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=AWS242ServiceCatalogService.CreatePortfolio' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "DisplayName": "",
  "Description": "",
  "ProviderName": "",
  "Tags": "",
  "IdempotencyToken": ""
}'

echo '{
  "AcceptLanguage": "",
  "DisplayName": "",
  "Description": "",
  "ProviderName": "",
  "Tags": "",
  "IdempotencyToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreatePortfolio' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "DisplayName": "",\n  "Description": "",\n  "ProviderName": "",\n  "Tags": "",\n  "IdempotencyToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreatePortfolio'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreatePortfolioShare

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "AccountId": "",
  "OrganizationNode": "",
  "ShareTagOptions": "",
  "SharePrincipals": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"AccountId\": \"\",\n  \"OrganizationNode\": \"\",\n  \"ShareTagOptions\": \"\",\n  \"SharePrincipals\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreatePortfolioShare" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:AcceptLanguage ""
                                                                                                                         :PortfolioId ""
                                                                                                                         :AccountId ""
                                                                                                                         :OrganizationNode ""
                                                                                                                         :ShareTagOptions ""
                                                                                                                         :SharePrincipals ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreatePortfolioShare"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"AccountId\": \"\",\n  \"OrganizationNode\": \"\",\n  \"ShareTagOptions\": \"\",\n  \"SharePrincipals\": \"\"\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: 142

{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "AccountId": "",
  "OrganizationNode": "",
  "ShareTagOptions": "",
  "SharePrincipals": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreatePortfolioShare")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"AccountId\": \"\",\n  \"OrganizationNode\": \"\",\n  \"ShareTagOptions\": \"\",\n  \"SharePrincipals\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

const data = JSON.stringify({
  AcceptLanguage: '',
  PortfolioId: '',
  AccountId: '',
  OrganizationNode: '',
  ShareTagOptions: '',
  SharePrincipals: ''
});

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=AWS242ServiceCatalogService.CreatePortfolioShare');
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=AWS242ServiceCatalogService.CreatePortfolioShare',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    PortfolioId: '',
    AccountId: '',
    OrganizationNode: '',
    ShareTagOptions: '',
    SharePrincipals: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreatePortfolioShare';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PortfolioId":"","AccountId":"","OrganizationNode":"","ShareTagOptions":"","SharePrincipals":""}'
};

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=AWS242ServiceCatalogService.CreatePortfolioShare',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "PortfolioId": "",\n  "AccountId": "",\n  "OrganizationNode": "",\n  "ShareTagOptions": "",\n  "SharePrincipals": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"AccountId\": \"\",\n  \"OrganizationNode\": \"\",\n  \"ShareTagOptions\": \"\",\n  \"SharePrincipals\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreatePortfolioShare")
  .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({
  AcceptLanguage: '',
  PortfolioId: '',
  AccountId: '',
  OrganizationNode: '',
  ShareTagOptions: '',
  SharePrincipals: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreatePortfolioShare',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AcceptLanguage: '',
    PortfolioId: '',
    AccountId: '',
    OrganizationNode: '',
    ShareTagOptions: '',
    SharePrincipals: ''
  },
  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=AWS242ServiceCatalogService.CreatePortfolioShare');

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

req.type('json');
req.send({
  AcceptLanguage: '',
  PortfolioId: '',
  AccountId: '',
  OrganizationNode: '',
  ShareTagOptions: '',
  SharePrincipals: ''
});

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=AWS242ServiceCatalogService.CreatePortfolioShare',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    PortfolioId: '',
    AccountId: '',
    OrganizationNode: '',
    ShareTagOptions: '',
    SharePrincipals: ''
  }
};

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=AWS242ServiceCatalogService.CreatePortfolioShare';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PortfolioId":"","AccountId":"","OrganizationNode":"","ShareTagOptions":"","SharePrincipals":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"PortfolioId": @"",
                              @"AccountId": @"",
                              @"OrganizationNode": @"",
                              @"ShareTagOptions": @"",
                              @"SharePrincipals": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreatePortfolioShare",
  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([
    'AcceptLanguage' => '',
    'PortfolioId' => '',
    'AccountId' => '',
    'OrganizationNode' => '',
    'ShareTagOptions' => '',
    'SharePrincipals' => ''
  ]),
  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=AWS242ServiceCatalogService.CreatePortfolioShare', [
  'body' => '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "AccountId": "",
  "OrganizationNode": "",
  "ShareTagOptions": "",
  "SharePrincipals": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'PortfolioId' => '',
  'AccountId' => '',
  'OrganizationNode' => '',
  'ShareTagOptions' => '',
  'SharePrincipals' => ''
]));

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

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

append(json_encode([
  'AcceptLanguage' => '',
  'PortfolioId' => '',
  'AccountId' => '',
  'OrganizationNode' => '',
  'ShareTagOptions' => '',
  'SharePrincipals' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreatePortfolioShare');
$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=AWS242ServiceCatalogService.CreatePortfolioShare' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "AccountId": "",
  "OrganizationNode": "",
  "ShareTagOptions": "",
  "SharePrincipals": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreatePortfolioShare' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "AccountId": "",
  "OrganizationNode": "",
  "ShareTagOptions": "",
  "SharePrincipals": ""
}'

import http.client

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

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"AccountId\": \"\",\n  \"OrganizationNode\": \"\",\n  \"ShareTagOptions\": \"\",\n  \"SharePrincipals\": \"\"\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=AWS242ServiceCatalogService.CreatePortfolioShare"

payload = {
    "AcceptLanguage": "",
    "PortfolioId": "",
    "AccountId": "",
    "OrganizationNode": "",
    "ShareTagOptions": "",
    "SharePrincipals": ""
}
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=AWS242ServiceCatalogService.CreatePortfolioShare"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"AccountId\": \"\",\n  \"OrganizationNode\": \"\",\n  \"ShareTagOptions\": \"\",\n  \"SharePrincipals\": \"\"\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=AWS242ServiceCatalogService.CreatePortfolioShare")

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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"AccountId\": \"\",\n  \"OrganizationNode\": \"\",\n  \"ShareTagOptions\": \"\",\n  \"SharePrincipals\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"AccountId\": \"\",\n  \"OrganizationNode\": \"\",\n  \"ShareTagOptions\": \"\",\n  \"SharePrincipals\": \"\"\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=AWS242ServiceCatalogService.CreatePortfolioShare";

    let payload = json!({
        "AcceptLanguage": "",
        "PortfolioId": "",
        "AccountId": "",
        "OrganizationNode": "",
        "ShareTagOptions": "",
        "SharePrincipals": ""
    });

    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=AWS242ServiceCatalogService.CreatePortfolioShare' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "AccountId": "",
  "OrganizationNode": "",
  "ShareTagOptions": "",
  "SharePrincipals": ""
}'

echo '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "AccountId": "",
  "OrganizationNode": "",
  "ShareTagOptions": "",
  "SharePrincipals": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreatePortfolioShare' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "PortfolioId": "",\n  "AccountId": "",\n  "OrganizationNode": "",\n  "ShareTagOptions": "",\n  "SharePrincipals": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreatePortfolioShare'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "PortfolioId": "",
  "AccountId": "",
  "OrganizationNode": "",
  "ShareTagOptions": "",
  "SharePrincipals": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProduct

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "Name": "",
  "Owner": "",
  "Description": "",
  "Distributor": "",
  "SupportDescription": "",
  "SupportEmail": "",
  "SupportUrl": "",
  "ProductType": "",
  "Tags": "",
  "ProvisioningArtifactParameters": "",
  "IdempotencyToken": "",
  "SourceConnection": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"AcceptLanguage\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"ProductType\": \"\",\n  \"Tags\": \"\",\n  \"ProvisioningArtifactParameters\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"SourceConnection\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProduct" {:headers {:x-amz-target ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:AcceptLanguage ""
                                                                                                                  :Name ""
                                                                                                                  :Owner ""
                                                                                                                  :Description ""
                                                                                                                  :Distributor ""
                                                                                                                  :SupportDescription ""
                                                                                                                  :SupportEmail ""
                                                                                                                  :SupportUrl ""
                                                                                                                  :ProductType ""
                                                                                                                  :Tags ""
                                                                                                                  :ProvisioningArtifactParameters ""
                                                                                                                  :IdempotencyToken ""
                                                                                                                  :SourceConnection ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProduct"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"ProductType\": \"\",\n  \"Tags\": \"\",\n  \"ProvisioningArtifactParameters\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"SourceConnection\": \"\"\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=AWS242ServiceCatalogService.CreateProduct"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"ProductType\": \"\",\n  \"Tags\": \"\",\n  \"ProvisioningArtifactParameters\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"SourceConnection\": \"\"\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=AWS242ServiceCatalogService.CreateProduct");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"ProductType\": \"\",\n  \"Tags\": \"\",\n  \"ProvisioningArtifactParameters\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"SourceConnection\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProduct"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"ProductType\": \"\",\n  \"Tags\": \"\",\n  \"ProvisioningArtifactParameters\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"SourceConnection\": \"\"\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: 294

{
  "AcceptLanguage": "",
  "Name": "",
  "Owner": "",
  "Description": "",
  "Distributor": "",
  "SupportDescription": "",
  "SupportEmail": "",
  "SupportUrl": "",
  "ProductType": "",
  "Tags": "",
  "ProvisioningArtifactParameters": "",
  "IdempotencyToken": "",
  "SourceConnection": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProduct")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"ProductType\": \"\",\n  \"Tags\": \"\",\n  \"ProvisioningArtifactParameters\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"SourceConnection\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProduct"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"ProductType\": \"\",\n  \"Tags\": \"\",\n  \"ProvisioningArtifactParameters\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"SourceConnection\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"ProductType\": \"\",\n  \"Tags\": \"\",\n  \"ProvisioningArtifactParameters\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"SourceConnection\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProduct")
  .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=AWS242ServiceCatalogService.CreateProduct")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"ProductType\": \"\",\n  \"Tags\": \"\",\n  \"ProvisioningArtifactParameters\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"SourceConnection\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  Name: '',
  Owner: '',
  Description: '',
  Distributor: '',
  SupportDescription: '',
  SupportEmail: '',
  SupportUrl: '',
  ProductType: '',
  Tags: '',
  ProvisioningArtifactParameters: '',
  IdempotencyToken: '',
  SourceConnection: ''
});

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=AWS242ServiceCatalogService.CreateProduct');
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=AWS242ServiceCatalogService.CreateProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    Name: '',
    Owner: '',
    Description: '',
    Distributor: '',
    SupportDescription: '',
    SupportEmail: '',
    SupportUrl: '',
    ProductType: '',
    Tags: '',
    ProvisioningArtifactParameters: '',
    IdempotencyToken: '',
    SourceConnection: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProduct';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","Name":"","Owner":"","Description":"","Distributor":"","SupportDescription":"","SupportEmail":"","SupportUrl":"","ProductType":"","Tags":"","ProvisioningArtifactParameters":"","IdempotencyToken":"","SourceConnection":""}'
};

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=AWS242ServiceCatalogService.CreateProduct',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "Name": "",\n  "Owner": "",\n  "Description": "",\n  "Distributor": "",\n  "SupportDescription": "",\n  "SupportEmail": "",\n  "SupportUrl": "",\n  "ProductType": "",\n  "Tags": "",\n  "ProvisioningArtifactParameters": "",\n  "IdempotencyToken": "",\n  "SourceConnection": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"ProductType\": \"\",\n  \"Tags\": \"\",\n  \"ProvisioningArtifactParameters\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"SourceConnection\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProduct")
  .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({
  AcceptLanguage: '',
  Name: '',
  Owner: '',
  Description: '',
  Distributor: '',
  SupportDescription: '',
  SupportEmail: '',
  SupportUrl: '',
  ProductType: '',
  Tags: '',
  ProvisioningArtifactParameters: '',
  IdempotencyToken: '',
  SourceConnection: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AcceptLanguage: '',
    Name: '',
    Owner: '',
    Description: '',
    Distributor: '',
    SupportDescription: '',
    SupportEmail: '',
    SupportUrl: '',
    ProductType: '',
    Tags: '',
    ProvisioningArtifactParameters: '',
    IdempotencyToken: '',
    SourceConnection: ''
  },
  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=AWS242ServiceCatalogService.CreateProduct');

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

req.type('json');
req.send({
  AcceptLanguage: '',
  Name: '',
  Owner: '',
  Description: '',
  Distributor: '',
  SupportDescription: '',
  SupportEmail: '',
  SupportUrl: '',
  ProductType: '',
  Tags: '',
  ProvisioningArtifactParameters: '',
  IdempotencyToken: '',
  SourceConnection: ''
});

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=AWS242ServiceCatalogService.CreateProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    Name: '',
    Owner: '',
    Description: '',
    Distributor: '',
    SupportDescription: '',
    SupportEmail: '',
    SupportUrl: '',
    ProductType: '',
    Tags: '',
    ProvisioningArtifactParameters: '',
    IdempotencyToken: '',
    SourceConnection: ''
  }
};

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=AWS242ServiceCatalogService.CreateProduct';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","Name":"","Owner":"","Description":"","Distributor":"","SupportDescription":"","SupportEmail":"","SupportUrl":"","ProductType":"","Tags":"","ProvisioningArtifactParameters":"","IdempotencyToken":"","SourceConnection":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"Name": @"",
                              @"Owner": @"",
                              @"Description": @"",
                              @"Distributor": @"",
                              @"SupportDescription": @"",
                              @"SupportEmail": @"",
                              @"SupportUrl": @"",
                              @"ProductType": @"",
                              @"Tags": @"",
                              @"ProvisioningArtifactParameters": @"",
                              @"IdempotencyToken": @"",
                              @"SourceConnection": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProduct"]
                                                       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=AWS242ServiceCatalogService.CreateProduct" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"ProductType\": \"\",\n  \"Tags\": \"\",\n  \"ProvisioningArtifactParameters\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"SourceConnection\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProduct",
  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([
    'AcceptLanguage' => '',
    'Name' => '',
    'Owner' => '',
    'Description' => '',
    'Distributor' => '',
    'SupportDescription' => '',
    'SupportEmail' => '',
    'SupportUrl' => '',
    'ProductType' => '',
    'Tags' => '',
    'ProvisioningArtifactParameters' => '',
    'IdempotencyToken' => '',
    'SourceConnection' => ''
  ]),
  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=AWS242ServiceCatalogService.CreateProduct', [
  'body' => '{
  "AcceptLanguage": "",
  "Name": "",
  "Owner": "",
  "Description": "",
  "Distributor": "",
  "SupportDescription": "",
  "SupportEmail": "",
  "SupportUrl": "",
  "ProductType": "",
  "Tags": "",
  "ProvisioningArtifactParameters": "",
  "IdempotencyToken": "",
  "SourceConnection": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'Name' => '',
  'Owner' => '',
  'Description' => '',
  'Distributor' => '',
  'SupportDescription' => '',
  'SupportEmail' => '',
  'SupportUrl' => '',
  'ProductType' => '',
  'Tags' => '',
  'ProvisioningArtifactParameters' => '',
  'IdempotencyToken' => '',
  'SourceConnection' => ''
]));

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

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

append(json_encode([
  'AcceptLanguage' => '',
  'Name' => '',
  'Owner' => '',
  'Description' => '',
  'Distributor' => '',
  'SupportDescription' => '',
  'SupportEmail' => '',
  'SupportUrl' => '',
  'ProductType' => '',
  'Tags' => '',
  'ProvisioningArtifactParameters' => '',
  'IdempotencyToken' => '',
  'SourceConnection' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProduct');
$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=AWS242ServiceCatalogService.CreateProduct' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "Name": "",
  "Owner": "",
  "Description": "",
  "Distributor": "",
  "SupportDescription": "",
  "SupportEmail": "",
  "SupportUrl": "",
  "ProductType": "",
  "Tags": "",
  "ProvisioningArtifactParameters": "",
  "IdempotencyToken": "",
  "SourceConnection": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProduct' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "Name": "",
  "Owner": "",
  "Description": "",
  "Distributor": "",
  "SupportDescription": "",
  "SupportEmail": "",
  "SupportUrl": "",
  "ProductType": "",
  "Tags": "",
  "ProvisioningArtifactParameters": "",
  "IdempotencyToken": "",
  "SourceConnection": ""
}'

import http.client

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

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"ProductType\": \"\",\n  \"Tags\": \"\",\n  \"ProvisioningArtifactParameters\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"SourceConnection\": \"\"\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=AWS242ServiceCatalogService.CreateProduct"

payload = {
    "AcceptLanguage": "",
    "Name": "",
    "Owner": "",
    "Description": "",
    "Distributor": "",
    "SupportDescription": "",
    "SupportEmail": "",
    "SupportUrl": "",
    "ProductType": "",
    "Tags": "",
    "ProvisioningArtifactParameters": "",
    "IdempotencyToken": "",
    "SourceConnection": ""
}
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=AWS242ServiceCatalogService.CreateProduct"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"ProductType\": \"\",\n  \"Tags\": \"\",\n  \"ProvisioningArtifactParameters\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"SourceConnection\": \"\"\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=AWS242ServiceCatalogService.CreateProduct")

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  \"AcceptLanguage\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"ProductType\": \"\",\n  \"Tags\": \"\",\n  \"ProvisioningArtifactParameters\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"SourceConnection\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"ProductType\": \"\",\n  \"Tags\": \"\",\n  \"ProvisioningArtifactParameters\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"SourceConnection\": \"\"\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=AWS242ServiceCatalogService.CreateProduct";

    let payload = json!({
        "AcceptLanguage": "",
        "Name": "",
        "Owner": "",
        "Description": "",
        "Distributor": "",
        "SupportDescription": "",
        "SupportEmail": "",
        "SupportUrl": "",
        "ProductType": "",
        "Tags": "",
        "ProvisioningArtifactParameters": "",
        "IdempotencyToken": "",
        "SourceConnection": ""
    });

    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=AWS242ServiceCatalogService.CreateProduct' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "Name": "",
  "Owner": "",
  "Description": "",
  "Distributor": "",
  "SupportDescription": "",
  "SupportEmail": "",
  "SupportUrl": "",
  "ProductType": "",
  "Tags": "",
  "ProvisioningArtifactParameters": "",
  "IdempotencyToken": "",
  "SourceConnection": ""
}'

echo '{
  "AcceptLanguage": "",
  "Name": "",
  "Owner": "",
  "Description": "",
  "Distributor": "",
  "SupportDescription": "",
  "SupportEmail": "",
  "SupportUrl": "",
  "ProductType": "",
  "Tags": "",
  "ProvisioningArtifactParameters": "",
  "IdempotencyToken": "",
  "SourceConnection": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProduct' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "Name": "",\n  "Owner": "",\n  "Description": "",\n  "Distributor": "",\n  "SupportDescription": "",\n  "SupportEmail": "",\n  "SupportUrl": "",\n  "ProductType": "",\n  "Tags": "",\n  "ProvisioningArtifactParameters": "",\n  "IdempotencyToken": "",\n  "SourceConnection": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProduct'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "Name": "",
  "Owner": "",
  "Description": "",
  "Distributor": "",
  "SupportDescription": "",
  "SupportEmail": "",
  "SupportUrl": "",
  "ProductType": "",
  "Tags": "",
  "ProvisioningArtifactParameters": "",
  "IdempotencyToken": "",
  "SourceConnection": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProvisionedProductPlan

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "PlanName": "",
  "PlanType": "",
  "NotificationArns": "",
  "PathId": "",
  "ProductId": "",
  "ProvisionedProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningParameters": "",
  "IdempotencyToken": "",
  "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=AWS242ServiceCatalogService.CreateProvisionedProductPlan");

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  \"AcceptLanguage\": \"\",\n  \"PlanName\": \"\",\n  \"PlanType\": \"\",\n  \"NotificationArns\": \"\",\n  \"PathId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProvisionedProductPlan" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:AcceptLanguage ""
                                                                                                                                 :PlanName ""
                                                                                                                                 :PlanType ""
                                                                                                                                 :NotificationArns ""
                                                                                                                                 :PathId ""
                                                                                                                                 :ProductId ""
                                                                                                                                 :ProvisionedProductName ""
                                                                                                                                 :ProvisioningArtifactId ""
                                                                                                                                 :ProvisioningParameters ""
                                                                                                                                 :IdempotencyToken ""
                                                                                                                                 :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProvisionedProductPlan"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"PlanName\": \"\",\n  \"PlanType\": \"\",\n  \"NotificationArns\": \"\",\n  \"PathId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"IdempotencyToken\": \"\",\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=AWS242ServiceCatalogService.CreateProvisionedProductPlan"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"PlanName\": \"\",\n  \"PlanType\": \"\",\n  \"NotificationArns\": \"\",\n  \"PathId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"IdempotencyToken\": \"\",\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=AWS242ServiceCatalogService.CreateProvisionedProductPlan");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"PlanName\": \"\",\n  \"PlanType\": \"\",\n  \"NotificationArns\": \"\",\n  \"PathId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"IdempotencyToken\": \"\",\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=AWS242ServiceCatalogService.CreateProvisionedProductPlan"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"PlanName\": \"\",\n  \"PlanType\": \"\",\n  \"NotificationArns\": \"\",\n  \"PathId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"IdempotencyToken\": \"\",\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: 259

{
  "AcceptLanguage": "",
  "PlanName": "",
  "PlanType": "",
  "NotificationArns": "",
  "PathId": "",
  "ProductId": "",
  "ProvisionedProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningParameters": "",
  "IdempotencyToken": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProvisionedProductPlan")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"PlanName\": \"\",\n  \"PlanType\": \"\",\n  \"NotificationArns\": \"\",\n  \"PathId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProvisionedProductPlan"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"PlanName\": \"\",\n  \"PlanType\": \"\",\n  \"NotificationArns\": \"\",\n  \"PathId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"IdempotencyToken\": \"\",\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  \"AcceptLanguage\": \"\",\n  \"PlanName\": \"\",\n  \"PlanType\": \"\",\n  \"NotificationArns\": \"\",\n  \"PathId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProvisionedProductPlan")
  .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=AWS242ServiceCatalogService.CreateProvisionedProductPlan")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"PlanName\": \"\",\n  \"PlanType\": \"\",\n  \"NotificationArns\": \"\",\n  \"PathId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  PlanName: '',
  PlanType: '',
  NotificationArns: '',
  PathId: '',
  ProductId: '',
  ProvisionedProductName: '',
  ProvisioningArtifactId: '',
  ProvisioningParameters: '',
  IdempotencyToken: '',
  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=AWS242ServiceCatalogService.CreateProvisionedProductPlan');
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=AWS242ServiceCatalogService.CreateProvisionedProductPlan',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    PlanName: '',
    PlanType: '',
    NotificationArns: '',
    PathId: '',
    ProductId: '',
    ProvisionedProductName: '',
    ProvisioningArtifactId: '',
    ProvisioningParameters: '',
    IdempotencyToken: '',
    Tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProvisionedProductPlan';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PlanName":"","PlanType":"","NotificationArns":"","PathId":"","ProductId":"","ProvisionedProductName":"","ProvisioningArtifactId":"","ProvisioningParameters":"","IdempotencyToken":"","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=AWS242ServiceCatalogService.CreateProvisionedProductPlan',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "PlanName": "",\n  "PlanType": "",\n  "NotificationArns": "",\n  "PathId": "",\n  "ProductId": "",\n  "ProvisionedProductName": "",\n  "ProvisioningArtifactId": "",\n  "ProvisioningParameters": "",\n  "IdempotencyToken": "",\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  \"AcceptLanguage\": \"\",\n  \"PlanName\": \"\",\n  \"PlanType\": \"\",\n  \"NotificationArns\": \"\",\n  \"PathId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProvisionedProductPlan")
  .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({
  AcceptLanguage: '',
  PlanName: '',
  PlanType: '',
  NotificationArns: '',
  PathId: '',
  ProductId: '',
  ProvisionedProductName: '',
  ProvisioningArtifactId: '',
  ProvisioningParameters: '',
  IdempotencyToken: '',
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProvisionedProductPlan',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AcceptLanguage: '',
    PlanName: '',
    PlanType: '',
    NotificationArns: '',
    PathId: '',
    ProductId: '',
    ProvisionedProductName: '',
    ProvisioningArtifactId: '',
    ProvisioningParameters: '',
    IdempotencyToken: '',
    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=AWS242ServiceCatalogService.CreateProvisionedProductPlan');

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

req.type('json');
req.send({
  AcceptLanguage: '',
  PlanName: '',
  PlanType: '',
  NotificationArns: '',
  PathId: '',
  ProductId: '',
  ProvisionedProductName: '',
  ProvisioningArtifactId: '',
  ProvisioningParameters: '',
  IdempotencyToken: '',
  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=AWS242ServiceCatalogService.CreateProvisionedProductPlan',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    PlanName: '',
    PlanType: '',
    NotificationArns: '',
    PathId: '',
    ProductId: '',
    ProvisionedProductName: '',
    ProvisioningArtifactId: '',
    ProvisioningParameters: '',
    IdempotencyToken: '',
    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=AWS242ServiceCatalogService.CreateProvisionedProductPlan';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PlanName":"","PlanType":"","NotificationArns":"","PathId":"","ProductId":"","ProvisionedProductName":"","ProvisioningArtifactId":"","ProvisioningParameters":"","IdempotencyToken":"","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 = @{ @"AcceptLanguage": @"",
                              @"PlanName": @"",
                              @"PlanType": @"",
                              @"NotificationArns": @"",
                              @"PathId": @"",
                              @"ProductId": @"",
                              @"ProvisionedProductName": @"",
                              @"ProvisioningArtifactId": @"",
                              @"ProvisioningParameters": @"",
                              @"IdempotencyToken": @"",
                              @"Tags": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProvisionedProductPlan"]
                                                       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=AWS242ServiceCatalogService.CreateProvisionedProductPlan" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"PlanName\": \"\",\n  \"PlanType\": \"\",\n  \"NotificationArns\": \"\",\n  \"PathId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"Tags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProvisionedProductPlan",
  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([
    'AcceptLanguage' => '',
    'PlanName' => '',
    'PlanType' => '',
    'NotificationArns' => '',
    'PathId' => '',
    'ProductId' => '',
    'ProvisionedProductName' => '',
    'ProvisioningArtifactId' => '',
    'ProvisioningParameters' => '',
    'IdempotencyToken' => '',
    '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=AWS242ServiceCatalogService.CreateProvisionedProductPlan', [
  'body' => '{
  "AcceptLanguage": "",
  "PlanName": "",
  "PlanType": "",
  "NotificationArns": "",
  "PathId": "",
  "ProductId": "",
  "ProvisionedProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningParameters": "",
  "IdempotencyToken": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'PlanName' => '',
  'PlanType' => '',
  'NotificationArns' => '',
  'PathId' => '',
  'ProductId' => '',
  'ProvisionedProductName' => '',
  'ProvisioningArtifactId' => '',
  'ProvisioningParameters' => '',
  'IdempotencyToken' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'AcceptLanguage' => '',
  'PlanName' => '',
  'PlanType' => '',
  'NotificationArns' => '',
  'PathId' => '',
  'ProductId' => '',
  'ProvisionedProductName' => '',
  'ProvisioningArtifactId' => '',
  'ProvisioningParameters' => '',
  'IdempotencyToken' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProvisionedProductPlan');
$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=AWS242ServiceCatalogService.CreateProvisionedProductPlan' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PlanName": "",
  "PlanType": "",
  "NotificationArns": "",
  "PathId": "",
  "ProductId": "",
  "ProvisionedProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningParameters": "",
  "IdempotencyToken": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProvisionedProductPlan' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PlanName": "",
  "PlanType": "",
  "NotificationArns": "",
  "PathId": "",
  "ProductId": "",
  "ProvisionedProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningParameters": "",
  "IdempotencyToken": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"PlanName\": \"\",\n  \"PlanType\": \"\",\n  \"NotificationArns\": \"\",\n  \"PathId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"IdempotencyToken\": \"\",\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=AWS242ServiceCatalogService.CreateProvisionedProductPlan"

payload = {
    "AcceptLanguage": "",
    "PlanName": "",
    "PlanType": "",
    "NotificationArns": "",
    "PathId": "",
    "ProductId": "",
    "ProvisionedProductName": "",
    "ProvisioningArtifactId": "",
    "ProvisioningParameters": "",
    "IdempotencyToken": "",
    "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=AWS242ServiceCatalogService.CreateProvisionedProductPlan"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"PlanName\": \"\",\n  \"PlanType\": \"\",\n  \"NotificationArns\": \"\",\n  \"PathId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"IdempotencyToken\": \"\",\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=AWS242ServiceCatalogService.CreateProvisionedProductPlan")

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  \"AcceptLanguage\": \"\",\n  \"PlanName\": \"\",\n  \"PlanType\": \"\",\n  \"NotificationArns\": \"\",\n  \"PathId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"IdempotencyToken\": \"\",\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  \"AcceptLanguage\": \"\",\n  \"PlanName\": \"\",\n  \"PlanType\": \"\",\n  \"NotificationArns\": \"\",\n  \"PathId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"IdempotencyToken\": \"\",\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=AWS242ServiceCatalogService.CreateProvisionedProductPlan";

    let payload = json!({
        "AcceptLanguage": "",
        "PlanName": "",
        "PlanType": "",
        "NotificationArns": "",
        "PathId": "",
        "ProductId": "",
        "ProvisionedProductName": "",
        "ProvisioningArtifactId": "",
        "ProvisioningParameters": "",
        "IdempotencyToken": "",
        "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=AWS242ServiceCatalogService.CreateProvisionedProductPlan' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "PlanName": "",
  "PlanType": "",
  "NotificationArns": "",
  "PathId": "",
  "ProductId": "",
  "ProvisionedProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningParameters": "",
  "IdempotencyToken": "",
  "Tags": ""
}'

echo '{
  "AcceptLanguage": "",
  "PlanName": "",
  "PlanType": "",
  "NotificationArns": "",
  "PathId": "",
  "ProductId": "",
  "ProvisionedProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningParameters": "",
  "IdempotencyToken": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProvisionedProductPlan' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "PlanName": "",\n  "PlanType": "",\n  "NotificationArns": "",\n  "PathId": "",\n  "ProductId": "",\n  "ProvisionedProductName": "",\n  "ProvisioningArtifactId": "",\n  "ProvisioningParameters": "",\n  "IdempotencyToken": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProvisionedProductPlan'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "PlanName": "",
  "PlanType": "",
  "NotificationArns": "",
  "PathId": "",
  "ProductId": "",
  "ProvisionedProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningParameters": "",
  "IdempotencyToken": "",
  "Tags": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProvisioningArtifact

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "ProductId": "",
  "Parameters": "",
  "IdempotencyToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"Parameters\": \"\",\n  \"IdempotencyToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProvisioningArtifact" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:AcceptLanguage ""
                                                                                                                               :ProductId ""
                                                                                                                               :Parameters ""
                                                                                                                               :IdempotencyToken ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProvisioningArtifact"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"Parameters\": \"\",\n  \"IdempotencyToken\": \"\"\n}")

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

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

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

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

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

}

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

{
  "AcceptLanguage": "",
  "ProductId": "",
  "Parameters": "",
  "IdempotencyToken": ""
}

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

client.close();

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

const data = JSON.stringify({
  AcceptLanguage: '',
  ProductId: '',
  Parameters: '',
  IdempotencyToken: ''
});

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=AWS242ServiceCatalogService.CreateProvisioningArtifact');
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=AWS242ServiceCatalogService.CreateProvisioningArtifact',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', ProductId: '', Parameters: '', IdempotencyToken: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProvisioningArtifact';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProductId":"","Parameters":"","IdempotencyToken":""}'
};

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=AWS242ServiceCatalogService.CreateProvisioningArtifact',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "ProductId": "",\n  "Parameters": "",\n  "IdempotencyToken": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  AcceptLanguage: '',
  ProductId: '',
  Parameters: '',
  IdempotencyToken: ''
});

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=AWS242ServiceCatalogService.CreateProvisioningArtifact',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', ProductId: '', Parameters: '', IdempotencyToken: ''}
};

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=AWS242ServiceCatalogService.CreateProvisioningArtifact';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProductId":"","Parameters":"","IdempotencyToken":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"ProductId": @"",
                              @"Parameters": @"",
                              @"IdempotencyToken": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'ProductId' => '',
  'Parameters' => '',
  'IdempotencyToken' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"Parameters\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.CreateProvisioningArtifact"

payload = {
    "AcceptLanguage": "",
    "ProductId": "",
    "Parameters": "",
    "IdempotencyToken": ""
}
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=AWS242ServiceCatalogService.CreateProvisioningArtifact"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"Parameters\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.CreateProvisioningArtifact")

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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"Parameters\": \"\",\n  \"IdempotencyToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"Parameters\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.CreateProvisioningArtifact";

    let payload = json!({
        "AcceptLanguage": "",
        "ProductId": "",
        "Parameters": "",
        "IdempotencyToken": ""
    });

    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=AWS242ServiceCatalogService.CreateProvisioningArtifact' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "ProductId": "",
  "Parameters": "",
  "IdempotencyToken": ""
}'

echo '{
  "AcceptLanguage": "",
  "ProductId": "",
  "Parameters": "",
  "IdempotencyToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProvisioningArtifact' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "ProductId": "",\n  "Parameters": "",\n  "IdempotencyToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateProvisioningArtifact'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateServiceAction

HEADERS

X-Amz-Target

BODY json

{
  "Name": "",
  "DefinitionType": "",
  "Definition": "",
  "Description": "",
  "AcceptLanguage": "",
  "IdempotencyToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"DefinitionType\": \"\",\n  \"Definition\": \"\",\n  \"Description\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"IdempotencyToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateServiceAction" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:Name ""
                                                                                                                        :DefinitionType ""
                                                                                                                        :Definition ""
                                                                                                                        :Description ""
                                                                                                                        :AcceptLanguage ""
                                                                                                                        :IdempotencyToken ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateServiceAction"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"DefinitionType\": \"\",\n  \"Definition\": \"\",\n  \"Description\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"IdempotencyToken\": \"\"\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: 131

{
  "Name": "",
  "DefinitionType": "",
  "Definition": "",
  "Description": "",
  "AcceptLanguage": "",
  "IdempotencyToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateServiceAction")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"DefinitionType\": \"\",\n  \"Definition\": \"\",\n  \"Description\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"IdempotencyToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

const data = JSON.stringify({
  Name: '',
  DefinitionType: '',
  Definition: '',
  Description: '',
  AcceptLanguage: '',
  IdempotencyToken: ''
});

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=AWS242ServiceCatalogService.CreateServiceAction');
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=AWS242ServiceCatalogService.CreateServiceAction',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    DefinitionType: '',
    Definition: '',
    Description: '',
    AcceptLanguage: '',
    IdempotencyToken: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateServiceAction';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","DefinitionType":"","Definition":"","Description":"","AcceptLanguage":"","IdempotencyToken":""}'
};

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=AWS242ServiceCatalogService.CreateServiceAction',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "DefinitionType": "",\n  "Definition": "",\n  "Description": "",\n  "AcceptLanguage": "",\n  "IdempotencyToken": ""\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  \"DefinitionType\": \"\",\n  \"Definition\": \"\",\n  \"Description\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"IdempotencyToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateServiceAction")
  .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: '',
  DefinitionType: '',
  Definition: '',
  Description: '',
  AcceptLanguage: '',
  IdempotencyToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateServiceAction',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    Name: '',
    DefinitionType: '',
    Definition: '',
    Description: '',
    AcceptLanguage: '',
    IdempotencyToken: ''
  },
  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=AWS242ServiceCatalogService.CreateServiceAction');

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

req.type('json');
req.send({
  Name: '',
  DefinitionType: '',
  Definition: '',
  Description: '',
  AcceptLanguage: '',
  IdempotencyToken: ''
});

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=AWS242ServiceCatalogService.CreateServiceAction',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    DefinitionType: '',
    Definition: '',
    Description: '',
    AcceptLanguage: '',
    IdempotencyToken: ''
  }
};

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=AWS242ServiceCatalogService.CreateServiceAction';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","DefinitionType":"","Definition":"","Description":"","AcceptLanguage":"","IdempotencyToken":""}'
};

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": @"",
                              @"DefinitionType": @"",
                              @"Definition": @"",
                              @"Description": @"",
                              @"AcceptLanguage": @"",
                              @"IdempotencyToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateServiceAction"]
                                                       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=AWS242ServiceCatalogService.CreateServiceAction" 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  \"DefinitionType\": \"\",\n  \"Definition\": \"\",\n  \"Description\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"IdempotencyToken\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateServiceAction",
  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' => '',
    'DefinitionType' => '',
    'Definition' => '',
    'Description' => '',
    'AcceptLanguage' => '',
    'IdempotencyToken' => ''
  ]),
  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=AWS242ServiceCatalogService.CreateServiceAction', [
  'body' => '{
  "Name": "",
  "DefinitionType": "",
  "Definition": "",
  "Description": "",
  "AcceptLanguage": "",
  "IdempotencyToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'DefinitionType' => '',
  'Definition' => '',
  'Description' => '',
  'AcceptLanguage' => '',
  'IdempotencyToken' => ''
]));

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

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

append(json_encode([
  'Name' => '',
  'DefinitionType' => '',
  'Definition' => '',
  'Description' => '',
  'AcceptLanguage' => '',
  'IdempotencyToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateServiceAction');
$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=AWS242ServiceCatalogService.CreateServiceAction' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "DefinitionType": "",
  "Definition": "",
  "Description": "",
  "AcceptLanguage": "",
  "IdempotencyToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateServiceAction' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "DefinitionType": "",
  "Definition": "",
  "Description": "",
  "AcceptLanguage": "",
  "IdempotencyToken": ""
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"DefinitionType\": \"\",\n  \"Definition\": \"\",\n  \"Description\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.CreateServiceAction"

payload = {
    "Name": "",
    "DefinitionType": "",
    "Definition": "",
    "Description": "",
    "AcceptLanguage": "",
    "IdempotencyToken": ""
}
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=AWS242ServiceCatalogService.CreateServiceAction"

payload <- "{\n  \"Name\": \"\",\n  \"DefinitionType\": \"\",\n  \"Definition\": \"\",\n  \"Description\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.CreateServiceAction")

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  \"DefinitionType\": \"\",\n  \"Definition\": \"\",\n  \"Description\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"IdempotencyToken\": \"\"\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  \"DefinitionType\": \"\",\n  \"Definition\": \"\",\n  \"Description\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.CreateServiceAction";

    let payload = json!({
        "Name": "",
        "DefinitionType": "",
        "Definition": "",
        "Description": "",
        "AcceptLanguage": "",
        "IdempotencyToken": ""
    });

    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=AWS242ServiceCatalogService.CreateServiceAction' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": "",
  "DefinitionType": "",
  "Definition": "",
  "Description": "",
  "AcceptLanguage": "",
  "IdempotencyToken": ""
}'

echo '{
  "Name": "",
  "DefinitionType": "",
  "Definition": "",
  "Description": "",
  "AcceptLanguage": "",
  "IdempotencyToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateServiceAction' \
  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  "DefinitionType": "",\n  "Definition": "",\n  "Description": "",\n  "AcceptLanguage": "",\n  "IdempotencyToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateServiceAction'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "DefinitionType": "",
  "Definition": "",
  "Description": "",
  "AcceptLanguage": "",
  "IdempotencyToken": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateTagOption

HEADERS

X-Amz-Target

BODY json

{
  "Key": "",
  "Value": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateTagOption" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:Key ""
                                                                                                                    :Value ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateTagOption"

	payload := strings.NewReader("{\n  \"Key\": \"\",\n  \"Value\": \"\"\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: 30

{
  "Key": "",
  "Value": ""
}

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

client.close();

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

const data = JSON.stringify({
  Key: '',
  Value: ''
});

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=AWS242ServiceCatalogService.CreateTagOption');
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=AWS242ServiceCatalogService.CreateTagOption',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Key: '', Value: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  Key: '',
  Value: ''
});

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=AWS242ServiceCatalogService.CreateTagOption',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Key: '', Value: ''}
};

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"Key\": \"\",\n  \"Value\": \"\"\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=AWS242ServiceCatalogService.CreateTagOption"

payload = {
    "Key": "",
    "Value": ""
}
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=AWS242ServiceCatalogService.CreateTagOption"

payload <- "{\n  \"Key\": \"\",\n  \"Value\": \"\"\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=AWS242ServiceCatalogService.CreateTagOption")

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  \"Key\": \"\",\n  \"Value\": \"\"\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  \"Key\": \"\",\n  \"Value\": \"\"\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=AWS242ServiceCatalogService.CreateTagOption";

    let payload = json!({
        "Key": "",
        "Value": ""
    });

    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=AWS242ServiceCatalogService.CreateTagOption' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Key": "",
  "Value": ""
}'

echo '{
  "Key": "",
  "Value": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.CreateTagOption' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeleteConstraint

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "Id": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeleteConstraint" {:headers {:x-amz-target ""}
                                                                                                       :content-type :json
                                                                                                       :form-params {:AcceptLanguage ""
                                                                                                                     :Id ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeleteConstraint"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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: 38

{
  "AcceptLanguage": "",
  "Id": ""
}

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

client.close();

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

const data = JSON.stringify({
  AcceptLanguage: '',
  Id: ''
});

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=AWS242ServiceCatalogService.DeleteConstraint');
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=AWS242ServiceCatalogService.DeleteConstraint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', Id: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  AcceptLanguage: '',
  Id: ''
});

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=AWS242ServiceCatalogService.DeleteConstraint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', Id: ''}
};

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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=AWS242ServiceCatalogService.DeleteConstraint"

payload = {
    "AcceptLanguage": "",
    "Id": ""
}
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=AWS242ServiceCatalogService.DeleteConstraint"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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=AWS242ServiceCatalogService.DeleteConstraint")

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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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=AWS242ServiceCatalogService.DeleteConstraint";

    let payload = json!({
        "AcceptLanguage": "",
        "Id": ""
    });

    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=AWS242ServiceCatalogService.DeleteConstraint' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "Id": ""
}'

echo '{
  "AcceptLanguage": "",
  "Id": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeleteConstraint' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeletePortfolio

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "Id": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeletePortfolio" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:AcceptLanguage ""
                                                                                                                    :Id ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeletePortfolio"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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: 38

{
  "AcceptLanguage": "",
  "Id": ""
}

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

client.close();

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

const data = JSON.stringify({
  AcceptLanguage: '',
  Id: ''
});

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=AWS242ServiceCatalogService.DeletePortfolio');
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=AWS242ServiceCatalogService.DeletePortfolio',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', Id: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  AcceptLanguage: '',
  Id: ''
});

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=AWS242ServiceCatalogService.DeletePortfolio',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', Id: ''}
};

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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=AWS242ServiceCatalogService.DeletePortfolio"

payload = {
    "AcceptLanguage": "",
    "Id": ""
}
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=AWS242ServiceCatalogService.DeletePortfolio"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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=AWS242ServiceCatalogService.DeletePortfolio")

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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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=AWS242ServiceCatalogService.DeletePortfolio";

    let payload = json!({
        "AcceptLanguage": "",
        "Id": ""
    });

    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=AWS242ServiceCatalogService.DeletePortfolio' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "Id": ""
}'

echo '{
  "AcceptLanguage": "",
  "Id": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeletePortfolio' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeletePortfolioShare

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "AccountId": "",
  "OrganizationNode": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"AccountId\": \"\",\n  \"OrganizationNode\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeletePortfolioShare" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:AcceptLanguage ""
                                                                                                                         :PortfolioId ""
                                                                                                                         :AccountId ""
                                                                                                                         :OrganizationNode ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeletePortfolioShare"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"AccountId\": \"\",\n  \"OrganizationNode\": \"\"\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: 92

{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "AccountId": "",
  "OrganizationNode": ""
}

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

client.close();

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

const data = JSON.stringify({
  AcceptLanguage: '',
  PortfolioId: '',
  AccountId: '',
  OrganizationNode: ''
});

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=AWS242ServiceCatalogService.DeletePortfolioShare');
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=AWS242ServiceCatalogService.DeletePortfolioShare',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', PortfolioId: '', AccountId: '', OrganizationNode: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeletePortfolioShare';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PortfolioId":"","AccountId":"","OrganizationNode":""}'
};

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=AWS242ServiceCatalogService.DeletePortfolioShare',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "PortfolioId": "",\n  "AccountId": "",\n  "OrganizationNode": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  AcceptLanguage: '',
  PortfolioId: '',
  AccountId: '',
  OrganizationNode: ''
});

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=AWS242ServiceCatalogService.DeletePortfolioShare',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', PortfolioId: '', AccountId: '', OrganizationNode: ''}
};

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=AWS242ServiceCatalogService.DeletePortfolioShare';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PortfolioId":"","AccountId":"","OrganizationNode":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"PortfolioId": @"",
                              @"AccountId": @"",
                              @"OrganizationNode": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'PortfolioId' => '',
  'AccountId' => '',
  'OrganizationNode' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"AccountId\": \"\",\n  \"OrganizationNode\": \"\"\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=AWS242ServiceCatalogService.DeletePortfolioShare"

payload = {
    "AcceptLanguage": "",
    "PortfolioId": "",
    "AccountId": "",
    "OrganizationNode": ""
}
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=AWS242ServiceCatalogService.DeletePortfolioShare"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"AccountId\": \"\",\n  \"OrganizationNode\": \"\"\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=AWS242ServiceCatalogService.DeletePortfolioShare")

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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"AccountId\": \"\",\n  \"OrganizationNode\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"AccountId\": \"\",\n  \"OrganizationNode\": \"\"\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=AWS242ServiceCatalogService.DeletePortfolioShare";

    let payload = json!({
        "AcceptLanguage": "",
        "PortfolioId": "",
        "AccountId": "",
        "OrganizationNode": ""
    });

    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=AWS242ServiceCatalogService.DeletePortfolioShare' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "AccountId": "",
  "OrganizationNode": ""
}'

echo '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "AccountId": "",
  "OrganizationNode": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeletePortfolioShare' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "PortfolioId": "",\n  "AccountId": "",\n  "OrganizationNode": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeletePortfolioShare'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeleteProduct

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "Id": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeleteProduct" {:headers {:x-amz-target ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:AcceptLanguage ""
                                                                                                                  :Id ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeleteProduct"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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: 38

{
  "AcceptLanguage": "",
  "Id": ""
}

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

client.close();

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

const data = JSON.stringify({
  AcceptLanguage: '',
  Id: ''
});

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=AWS242ServiceCatalogService.DeleteProduct');
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=AWS242ServiceCatalogService.DeleteProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', Id: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  AcceptLanguage: '',
  Id: ''
});

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=AWS242ServiceCatalogService.DeleteProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', Id: ''}
};

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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=AWS242ServiceCatalogService.DeleteProduct"

payload = {
    "AcceptLanguage": "",
    "Id": ""
}
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=AWS242ServiceCatalogService.DeleteProduct"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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=AWS242ServiceCatalogService.DeleteProduct")

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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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=AWS242ServiceCatalogService.DeleteProduct";

    let payload = json!({
        "AcceptLanguage": "",
        "Id": ""
    });

    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=AWS242ServiceCatalogService.DeleteProduct' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "Id": ""
}'

echo '{
  "AcceptLanguage": "",
  "Id": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeleteProduct' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeleteProvisionedProductPlan

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "PlanId": "",
  "IgnoreErrors": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"IgnoreErrors\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeleteProvisionedProductPlan" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:AcceptLanguage ""
                                                                                                                                 :PlanId ""
                                                                                                                                 :IgnoreErrors ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeleteProvisionedProductPlan"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"IgnoreErrors\": \"\"\n}")

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

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

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

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

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

}

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

{
  "AcceptLanguage": "",
  "PlanId": "",
  "IgnoreErrors": ""
}

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

client.close();

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

const data = JSON.stringify({
  AcceptLanguage: '',
  PlanId: '',
  IgnoreErrors: ''
});

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=AWS242ServiceCatalogService.DeleteProvisionedProductPlan');
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=AWS242ServiceCatalogService.DeleteProvisionedProductPlan',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', PlanId: '', IgnoreErrors: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeleteProvisionedProductPlan';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PlanId":"","IgnoreErrors":""}'
};

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  AcceptLanguage: '',
  PlanId: '',
  IgnoreErrors: ''
});

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=AWS242ServiceCatalogService.DeleteProvisionedProductPlan',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', PlanId: '', IgnoreErrors: ''}
};

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=AWS242ServiceCatalogService.DeleteProvisionedProductPlan';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PlanId":"","IgnoreErrors":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"PlanId": @"",
                              @"IgnoreErrors": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'PlanId' => '',
  'IgnoreErrors' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"IgnoreErrors\": \"\"\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=AWS242ServiceCatalogService.DeleteProvisionedProductPlan"

payload = {
    "AcceptLanguage": "",
    "PlanId": "",
    "IgnoreErrors": ""
}
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=AWS242ServiceCatalogService.DeleteProvisionedProductPlan"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"IgnoreErrors\": \"\"\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=AWS242ServiceCatalogService.DeleteProvisionedProductPlan")

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  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"IgnoreErrors\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"IgnoreErrors\": \"\"\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=AWS242ServiceCatalogService.DeleteProvisionedProductPlan";

    let payload = json!({
        "AcceptLanguage": "",
        "PlanId": "",
        "IgnoreErrors": ""
    });

    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=AWS242ServiceCatalogService.DeleteProvisionedProductPlan' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "PlanId": "",
  "IgnoreErrors": ""
}'

echo '{
  "AcceptLanguage": "",
  "PlanId": "",
  "IgnoreErrors": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeleteProvisionedProductPlan' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "PlanId": "",\n  "IgnoreErrors": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeleteProvisionedProductPlan'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeleteProvisioningArtifact

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProvisioningArtifactId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeleteProvisioningArtifact" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:AcceptLanguage ""
                                                                                                                               :ProductId ""
                                                                                                                               :ProvisioningArtifactId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeleteProvisioningArtifact"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\"\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

{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProvisioningArtifactId": ""
}

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

client.close();

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

const data = JSON.stringify({
  AcceptLanguage: '',
  ProductId: '',
  ProvisioningArtifactId: ''
});

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=AWS242ServiceCatalogService.DeleteProvisioningArtifact');
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=AWS242ServiceCatalogService.DeleteProvisioningArtifact',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', ProductId: '', ProvisioningArtifactId: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeleteProvisioningArtifact';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProductId":"","ProvisioningArtifactId":""}'
};

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  AcceptLanguage: '',
  ProductId: '',
  ProvisioningArtifactId: ''
});

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=AWS242ServiceCatalogService.DeleteProvisioningArtifact',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', ProductId: '', ProvisioningArtifactId: ''}
};

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=AWS242ServiceCatalogService.DeleteProvisioningArtifact';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProductId":"","ProvisioningArtifactId":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"ProductId": @"",
                              @"ProvisioningArtifactId": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'ProductId' => '',
  'ProvisioningArtifactId' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\"\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=AWS242ServiceCatalogService.DeleteProvisioningArtifact"

payload = {
    "AcceptLanguage": "",
    "ProductId": "",
    "ProvisioningArtifactId": ""
}
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=AWS242ServiceCatalogService.DeleteProvisioningArtifact"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\"\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=AWS242ServiceCatalogService.DeleteProvisioningArtifact")

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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\"\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=AWS242ServiceCatalogService.DeleteProvisioningArtifact";

    let payload = json!({
        "AcceptLanguage": "",
        "ProductId": "",
        "ProvisioningArtifactId": ""
    });

    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=AWS242ServiceCatalogService.DeleteProvisioningArtifact' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProvisioningArtifactId": ""
}'

echo '{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProvisioningArtifactId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeleteProvisioningArtifact' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "ProductId": "",\n  "ProvisioningArtifactId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeleteProvisioningArtifact'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeleteServiceAction

HEADERS

X-Amz-Target

BODY json

{
  "Id": "",
  "AcceptLanguage": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeleteServiceAction" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:Id ""
                                                                                                                        :AcceptLanguage ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeleteServiceAction"

	payload := strings.NewReader("{\n  \"Id\": \"\",\n  \"AcceptLanguage\": \"\"\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: 38

{
  "Id": "",
  "AcceptLanguage": ""
}

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

client.close();

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

const data = JSON.stringify({
  Id: '',
  AcceptLanguage: ''
});

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=AWS242ServiceCatalogService.DeleteServiceAction');
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=AWS242ServiceCatalogService.DeleteServiceAction',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Id: '', AcceptLanguage: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  Id: '',
  AcceptLanguage: ''
});

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=AWS242ServiceCatalogService.DeleteServiceAction',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Id: '', AcceptLanguage: ''}
};

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"Id\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.DeleteServiceAction"

payload = {
    "Id": "",
    "AcceptLanguage": ""
}
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=AWS242ServiceCatalogService.DeleteServiceAction"

payload <- "{\n  \"Id\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.DeleteServiceAction")

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  \"Id\": \"\",\n  \"AcceptLanguage\": \"\"\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  \"Id\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.DeleteServiceAction";

    let payload = json!({
        "Id": "",
        "AcceptLanguage": ""
    });

    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=AWS242ServiceCatalogService.DeleteServiceAction' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Id": "",
  "AcceptLanguage": ""
}'

echo '{
  "Id": "",
  "AcceptLanguage": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeleteServiceAction' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeleteTagOption

HEADERS

X-Amz-Target

BODY json

{
  "Id": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DeleteTagOption"

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

{
  "Id": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"Id\": \"\"\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=AWS242ServiceCatalogService.DeleteTagOption"

payload = { "Id": "" }
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=AWS242ServiceCatalogService.DeleteTagOption"

payload <- "{\n  \"Id\": \"\"\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=AWS242ServiceCatalogService.DeleteTagOption")

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  \"Id\": \"\"\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  \"Id\": \"\"\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=AWS242ServiceCatalogService.DeleteTagOption";

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

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

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

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeConstraint

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "Id": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeConstraint" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:AcceptLanguage ""
                                                                                                                       :Id ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeConstraint"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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: 38

{
  "AcceptLanguage": "",
  "Id": ""
}

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

client.close();

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

const data = JSON.stringify({
  AcceptLanguage: '',
  Id: ''
});

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=AWS242ServiceCatalogService.DescribeConstraint');
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=AWS242ServiceCatalogService.DescribeConstraint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', Id: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  AcceptLanguage: '',
  Id: ''
});

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=AWS242ServiceCatalogService.DescribeConstraint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', Id: ''}
};

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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=AWS242ServiceCatalogService.DescribeConstraint"

payload = {
    "AcceptLanguage": "",
    "Id": ""
}
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=AWS242ServiceCatalogService.DescribeConstraint"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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=AWS242ServiceCatalogService.DescribeConstraint")

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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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=AWS242ServiceCatalogService.DescribeConstraint";

    let payload = json!({
        "AcceptLanguage": "",
        "Id": ""
    });

    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=AWS242ServiceCatalogService.DescribeConstraint' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "Id": ""
}'

echo '{
  "AcceptLanguage": "",
  "Id": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeConstraint' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeCopyProductStatus

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "CopyProductToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeCopyProductStatus" {:headers {:x-amz-target ""}
                                                                                                                :content-type :json
                                                                                                                :form-params {:AcceptLanguage ""
                                                                                                                              :CopyProductToken ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeCopyProductStatus"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"CopyProductToken\": \"\"\n}")

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

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

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

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

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

}

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

{
  "AcceptLanguage": "",
  "CopyProductToken": ""
}

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

client.close();

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

const data = JSON.stringify({
  AcceptLanguage: '',
  CopyProductToken: ''
});

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=AWS242ServiceCatalogService.DescribeCopyProductStatus');
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=AWS242ServiceCatalogService.DescribeCopyProductStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', CopyProductToken: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  AcceptLanguage: '',
  CopyProductToken: ''
});

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=AWS242ServiceCatalogService.DescribeCopyProductStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', CopyProductToken: ''}
};

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"CopyProductToken\": \"\"\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=AWS242ServiceCatalogService.DescribeCopyProductStatus"

payload = {
    "AcceptLanguage": "",
    "CopyProductToken": ""
}
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=AWS242ServiceCatalogService.DescribeCopyProductStatus"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"CopyProductToken\": \"\"\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=AWS242ServiceCatalogService.DescribeCopyProductStatus")

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  \"AcceptLanguage\": \"\",\n  \"CopyProductToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"CopyProductToken\": \"\"\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=AWS242ServiceCatalogService.DescribeCopyProductStatus";

    let payload = json!({
        "AcceptLanguage": "",
        "CopyProductToken": ""
    });

    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=AWS242ServiceCatalogService.DescribeCopyProductStatus' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "CopyProductToken": ""
}'

echo '{
  "AcceptLanguage": "",
  "CopyProductToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeCopyProductStatus' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolio

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "Id": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolio" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:AcceptLanguage ""
                                                                                                                      :Id ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolio"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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: 38

{
  "AcceptLanguage": "",
  "Id": ""
}

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

client.close();

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

const data = JSON.stringify({
  AcceptLanguage: '',
  Id: ''
});

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=AWS242ServiceCatalogService.DescribePortfolio');
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=AWS242ServiceCatalogService.DescribePortfolio',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', Id: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  AcceptLanguage: '',
  Id: ''
});

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=AWS242ServiceCatalogService.DescribePortfolio',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', Id: ''}
};

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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=AWS242ServiceCatalogService.DescribePortfolio"

payload = {
    "AcceptLanguage": "",
    "Id": ""
}
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=AWS242ServiceCatalogService.DescribePortfolio"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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=AWS242ServiceCatalogService.DescribePortfolio")

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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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=AWS242ServiceCatalogService.DescribePortfolio";

    let payload = json!({
        "AcceptLanguage": "",
        "Id": ""
    });

    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=AWS242ServiceCatalogService.DescribePortfolio' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "Id": ""
}'

echo '{
  "AcceptLanguage": "",
  "Id": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolio' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShareStatus

HEADERS

X-Amz-Target

BODY json

{
  "PortfolioShareToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShareStatus");

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  \"PortfolioShareToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShareStatus" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:PortfolioShareToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShareStatus"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"PortfolioShareToken\": \"\"\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=AWS242ServiceCatalogService.DescribePortfolioShareStatus"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"PortfolioShareToken\": \"\"\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=AWS242ServiceCatalogService.DescribePortfolioShareStatus");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"PortfolioShareToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShareStatus"

	payload := strings.NewReader("{\n  \"PortfolioShareToken\": \"\"\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: 31

{
  "PortfolioShareToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShareStatus")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"PortfolioShareToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShareStatus"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"PortfolioShareToken\": \"\"\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  \"PortfolioShareToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShareStatus")
  .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=AWS242ServiceCatalogService.DescribePortfolioShareStatus")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"PortfolioShareToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  PortfolioShareToken: ''
});

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=AWS242ServiceCatalogService.DescribePortfolioShareStatus');
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=AWS242ServiceCatalogService.DescribePortfolioShareStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {PortfolioShareToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShareStatus';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"PortfolioShareToken":""}'
};

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=AWS242ServiceCatalogService.DescribePortfolioShareStatus',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "PortfolioShareToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"PortfolioShareToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShareStatus")
  .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({PortfolioShareToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShareStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {PortfolioShareToken: ''},
  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=AWS242ServiceCatalogService.DescribePortfolioShareStatus');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  PortfolioShareToken: ''
});

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=AWS242ServiceCatalogService.DescribePortfolioShareStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {PortfolioShareToken: ''}
};

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=AWS242ServiceCatalogService.DescribePortfolioShareStatus';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"PortfolioShareToken":""}'
};

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 = @{ @"PortfolioShareToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShareStatus"]
                                                       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=AWS242ServiceCatalogService.DescribePortfolioShareStatus" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"PortfolioShareToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShareStatus",
  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([
    'PortfolioShareToken' => ''
  ]),
  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=AWS242ServiceCatalogService.DescribePortfolioShareStatus', [
  'body' => '{
  "PortfolioShareToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShareStatus');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'PortfolioShareToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'PortfolioShareToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShareStatus');
$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=AWS242ServiceCatalogService.DescribePortfolioShareStatus' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "PortfolioShareToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShareStatus' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "PortfolioShareToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"PortfolioShareToken\": \"\"\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=AWS242ServiceCatalogService.DescribePortfolioShareStatus"

payload = { "PortfolioShareToken": "" }
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=AWS242ServiceCatalogService.DescribePortfolioShareStatus"

payload <- "{\n  \"PortfolioShareToken\": \"\"\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=AWS242ServiceCatalogService.DescribePortfolioShareStatus")

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  \"PortfolioShareToken\": \"\"\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  \"PortfolioShareToken\": \"\"\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=AWS242ServiceCatalogService.DescribePortfolioShareStatus";

    let payload = json!({"PortfolioShareToken": ""});

    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=AWS242ServiceCatalogService.DescribePortfolioShareStatus' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "PortfolioShareToken": ""
}'

echo '{
  "PortfolioShareToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShareStatus' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "PortfolioShareToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShareStatus'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["PortfolioShareToken": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShareStatus")! 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 DescribePortfolioShares

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShares

HEADERS

X-Amz-Target

BODY json

{
  "PortfolioId": "",
  "Type": "",
  "PageToken": "",
  "PageSize": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShares");

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  \"PortfolioId\": \"\",\n  \"Type\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShares" {:headers {:x-amz-target ""}
                                                                                                              :content-type :json
                                                                                                              :form-params {:PortfolioId ""
                                                                                                                            :Type ""
                                                                                                                            :PageToken ""
                                                                                                                            :PageSize ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShares"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"PortfolioId\": \"\",\n  \"Type\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.DescribePortfolioShares"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"PortfolioId\": \"\",\n  \"Type\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.DescribePortfolioShares");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"PortfolioId\": \"\",\n  \"Type\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShares"

	payload := strings.NewReader("{\n  \"PortfolioId\": \"\",\n  \"Type\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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

{
  "PortfolioId": "",
  "Type": "",
  "PageToken": "",
  "PageSize": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShares")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"PortfolioId\": \"\",\n  \"Type\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShares"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"PortfolioId\": \"\",\n  \"Type\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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  \"PortfolioId\": \"\",\n  \"Type\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShares")
  .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=AWS242ServiceCatalogService.DescribePortfolioShares")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"PortfolioId\": \"\",\n  \"Type\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  PortfolioId: '',
  Type: '',
  PageToken: '',
  PageSize: ''
});

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=AWS242ServiceCatalogService.DescribePortfolioShares');
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=AWS242ServiceCatalogService.DescribePortfolioShares',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {PortfolioId: '', Type: '', PageToken: '', PageSize: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShares';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"PortfolioId":"","Type":"","PageToken":"","PageSize":""}'
};

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=AWS242ServiceCatalogService.DescribePortfolioShares',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "PortfolioId": "",\n  "Type": "",\n  "PageToken": "",\n  "PageSize": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"PortfolioId\": \"\",\n  \"Type\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShares")
  .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({PortfolioId: '', Type: '', PageToken: '', PageSize: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShares',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {PortfolioId: '', Type: '', PageToken: '', PageSize: ''},
  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=AWS242ServiceCatalogService.DescribePortfolioShares');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  PortfolioId: '',
  Type: '',
  PageToken: '',
  PageSize: ''
});

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=AWS242ServiceCatalogService.DescribePortfolioShares',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {PortfolioId: '', Type: '', PageToken: '', PageSize: ''}
};

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=AWS242ServiceCatalogService.DescribePortfolioShares';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"PortfolioId":"","Type":"","PageToken":"","PageSize":""}'
};

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 = @{ @"PortfolioId": @"",
                              @"Type": @"",
                              @"PageToken": @"",
                              @"PageSize": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShares"]
                                                       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=AWS242ServiceCatalogService.DescribePortfolioShares" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"PortfolioId\": \"\",\n  \"Type\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShares",
  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([
    'PortfolioId' => '',
    'Type' => '',
    'PageToken' => '',
    'PageSize' => ''
  ]),
  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=AWS242ServiceCatalogService.DescribePortfolioShares', [
  'body' => '{
  "PortfolioId": "",
  "Type": "",
  "PageToken": "",
  "PageSize": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShares');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'PortfolioId' => '',
  'Type' => '',
  'PageToken' => '',
  'PageSize' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'PortfolioId' => '',
  'Type' => '',
  'PageToken' => '',
  'PageSize' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShares');
$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=AWS242ServiceCatalogService.DescribePortfolioShares' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "PortfolioId": "",
  "Type": "",
  "PageToken": "",
  "PageSize": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShares' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "PortfolioId": "",
  "Type": "",
  "PageToken": "",
  "PageSize": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"PortfolioId\": \"\",\n  \"Type\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.DescribePortfolioShares"

payload = {
    "PortfolioId": "",
    "Type": "",
    "PageToken": "",
    "PageSize": ""
}
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=AWS242ServiceCatalogService.DescribePortfolioShares"

payload <- "{\n  \"PortfolioId\": \"\",\n  \"Type\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.DescribePortfolioShares")

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  \"PortfolioId\": \"\",\n  \"Type\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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  \"PortfolioId\": \"\",\n  \"Type\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.DescribePortfolioShares";

    let payload = json!({
        "PortfolioId": "",
        "Type": "",
        "PageToken": "",
        "PageSize": ""
    });

    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=AWS242ServiceCatalogService.DescribePortfolioShares' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "PortfolioId": "",
  "Type": "",
  "PageToken": "",
  "PageSize": ""
}'

echo '{
  "PortfolioId": "",
  "Type": "",
  "PageToken": "",
  "PageSize": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShares' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "PortfolioId": "",\n  "Type": "",\n  "PageToken": "",\n  "PageSize": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShares'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "PortfolioId": "",
  "Type": "",
  "PageToken": "",
  "PageSize": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribePortfolioShares")! 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 DescribeProduct

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProduct

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "Id": "",
  "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=AWS242ServiceCatalogService.DescribeProduct");

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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProduct" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:AcceptLanguage ""
                                                                                                                    :Id ""
                                                                                                                    :Name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProduct"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\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=AWS242ServiceCatalogService.DescribeProduct"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\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=AWS242ServiceCatalogService.DescribeProduct");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\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=AWS242ServiceCatalogService.DescribeProduct"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\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: 52

{
  "AcceptLanguage": "",
  "Id": "",
  "Name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProduct")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProduct"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProduct")
  .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=AWS242ServiceCatalogService.DescribeProduct")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  Id: '',
  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=AWS242ServiceCatalogService.DescribeProduct');
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=AWS242ServiceCatalogService.DescribeProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', Id: '', Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProduct';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","Id":"","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=AWS242ServiceCatalogService.DescribeProduct',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "Id": "",\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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProduct")
  .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({AcceptLanguage: '', Id: '', Name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AcceptLanguage: '', Id: '', 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=AWS242ServiceCatalogService.DescribeProduct');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  Id: '',
  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=AWS242ServiceCatalogService.DescribeProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', Id: '', 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=AWS242ServiceCatalogService.DescribeProduct';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","Id":"","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 = @{ @"AcceptLanguage": @"",
                              @"Id": @"",
                              @"Name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProduct"]
                                                       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=AWS242ServiceCatalogService.DescribeProduct" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProduct",
  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([
    'AcceptLanguage' => '',
    'Id' => '',
    '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=AWS242ServiceCatalogService.DescribeProduct', [
  'body' => '{
  "AcceptLanguage": "",
  "Id": "",
  "Name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProduct');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'Id' => '',
  'Name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'Id' => '',
  'Name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProduct');
$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=AWS242ServiceCatalogService.DescribeProduct' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "Id": "",
  "Name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProduct' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "Id": "",
  "Name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\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=AWS242ServiceCatalogService.DescribeProduct"

payload = {
    "AcceptLanguage": "",
    "Id": "",
    "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=AWS242ServiceCatalogService.DescribeProduct"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\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=AWS242ServiceCatalogService.DescribeProduct")

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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\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=AWS242ServiceCatalogService.DescribeProduct";

    let payload = json!({
        "AcceptLanguage": "",
        "Id": "",
        "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=AWS242ServiceCatalogService.DescribeProduct' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "Id": "",
  "Name": ""
}'

echo '{
  "AcceptLanguage": "",
  "Id": "",
  "Name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProduct' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "Id": "",\n  "Name": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProduct'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "Id": "",
  "Name": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProduct")! 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 DescribeProductAsAdmin

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductAsAdmin

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "Id": "",
  "Name": "",
  "SourcePortfolioId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductAsAdmin");

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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"SourcePortfolioId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductAsAdmin" {:headers {:x-amz-target ""}
                                                                                                             :content-type :json
                                                                                                             :form-params {:AcceptLanguage ""
                                                                                                                           :Id ""
                                                                                                                           :Name ""
                                                                                                                           :SourcePortfolioId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductAsAdmin"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"SourcePortfolioId\": \"\"\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=AWS242ServiceCatalogService.DescribeProductAsAdmin"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"SourcePortfolioId\": \"\"\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=AWS242ServiceCatalogService.DescribeProductAsAdmin");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"SourcePortfolioId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductAsAdmin"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"SourcePortfolioId\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 79

{
  "AcceptLanguage": "",
  "Id": "",
  "Name": "",
  "SourcePortfolioId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductAsAdmin")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"SourcePortfolioId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductAsAdmin"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"SourcePortfolioId\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"SourcePortfolioId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductAsAdmin")
  .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=AWS242ServiceCatalogService.DescribeProductAsAdmin")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"SourcePortfolioId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  Id: '',
  Name: '',
  SourcePortfolioId: ''
});

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=AWS242ServiceCatalogService.DescribeProductAsAdmin');
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=AWS242ServiceCatalogService.DescribeProductAsAdmin',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', Id: '', Name: '', SourcePortfolioId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductAsAdmin';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","Id":"","Name":"","SourcePortfolioId":""}'
};

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=AWS242ServiceCatalogService.DescribeProductAsAdmin',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "Id": "",\n  "Name": "",\n  "SourcePortfolioId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"SourcePortfolioId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductAsAdmin")
  .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({AcceptLanguage: '', Id: '', Name: '', SourcePortfolioId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductAsAdmin',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AcceptLanguage: '', Id: '', Name: '', SourcePortfolioId: ''},
  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=AWS242ServiceCatalogService.DescribeProductAsAdmin');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  Id: '',
  Name: '',
  SourcePortfolioId: ''
});

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=AWS242ServiceCatalogService.DescribeProductAsAdmin',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', Id: '', Name: '', SourcePortfolioId: ''}
};

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=AWS242ServiceCatalogService.DescribeProductAsAdmin';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","Id":"","Name":"","SourcePortfolioId":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"Id": @"",
                              @"Name": @"",
                              @"SourcePortfolioId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductAsAdmin"]
                                                       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=AWS242ServiceCatalogService.DescribeProductAsAdmin" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"SourcePortfolioId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductAsAdmin",
  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([
    'AcceptLanguage' => '',
    'Id' => '',
    'Name' => '',
    'SourcePortfolioId' => ''
  ]),
  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=AWS242ServiceCatalogService.DescribeProductAsAdmin', [
  'body' => '{
  "AcceptLanguage": "",
  "Id": "",
  "Name": "",
  "SourcePortfolioId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductAsAdmin');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'Id' => '',
  'Name' => '',
  'SourcePortfolioId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'Id' => '',
  'Name' => '',
  'SourcePortfolioId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductAsAdmin');
$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=AWS242ServiceCatalogService.DescribeProductAsAdmin' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "Id": "",
  "Name": "",
  "SourcePortfolioId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductAsAdmin' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "Id": "",
  "Name": "",
  "SourcePortfolioId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"SourcePortfolioId\": \"\"\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=AWS242ServiceCatalogService.DescribeProductAsAdmin"

payload = {
    "AcceptLanguage": "",
    "Id": "",
    "Name": "",
    "SourcePortfolioId": ""
}
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=AWS242ServiceCatalogService.DescribeProductAsAdmin"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"SourcePortfolioId\": \"\"\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=AWS242ServiceCatalogService.DescribeProductAsAdmin")

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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"SourcePortfolioId\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"SourcePortfolioId\": \"\"\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=AWS242ServiceCatalogService.DescribeProductAsAdmin";

    let payload = json!({
        "AcceptLanguage": "",
        "Id": "",
        "Name": "",
        "SourcePortfolioId": ""
    });

    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=AWS242ServiceCatalogService.DescribeProductAsAdmin' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "Id": "",
  "Name": "",
  "SourcePortfolioId": ""
}'

echo '{
  "AcceptLanguage": "",
  "Id": "",
  "Name": "",
  "SourcePortfolioId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductAsAdmin' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "Id": "",\n  "Name": "",\n  "SourcePortfolioId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductAsAdmin'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "Id": "",
  "Name": "",
  "SourcePortfolioId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductAsAdmin")! 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 DescribeProductView

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductView

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "Id": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductView");

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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductView" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:AcceptLanguage ""
                                                                                                                        :Id ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductView"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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=AWS242ServiceCatalogService.DescribeProductView"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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=AWS242ServiceCatalogService.DescribeProductView");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductView"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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: 38

{
  "AcceptLanguage": "",
  "Id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductView")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductView"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductView")
  .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=AWS242ServiceCatalogService.DescribeProductView")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  Id: ''
});

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=AWS242ServiceCatalogService.DescribeProductView');
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=AWS242ServiceCatalogService.DescribeProductView',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', Id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductView';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","Id":""}'
};

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=AWS242ServiceCatalogService.DescribeProductView',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "Id": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductView")
  .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({AcceptLanguage: '', Id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductView',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AcceptLanguage: '', Id: ''},
  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=AWS242ServiceCatalogService.DescribeProductView');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  Id: ''
});

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=AWS242ServiceCatalogService.DescribeProductView',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', Id: ''}
};

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=AWS242ServiceCatalogService.DescribeProductView';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","Id":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"Id": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductView"]
                                                       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=AWS242ServiceCatalogService.DescribeProductView" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductView",
  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([
    'AcceptLanguage' => '',
    'Id' => ''
  ]),
  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=AWS242ServiceCatalogService.DescribeProductView', [
  'body' => '{
  "AcceptLanguage": "",
  "Id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductView');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'Id' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'Id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductView');
$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=AWS242ServiceCatalogService.DescribeProductView' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "Id": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductView' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "Id": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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=AWS242ServiceCatalogService.DescribeProductView"

payload = {
    "AcceptLanguage": "",
    "Id": ""
}
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=AWS242ServiceCatalogService.DescribeProductView"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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=AWS242ServiceCatalogService.DescribeProductView")

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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\"\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=AWS242ServiceCatalogService.DescribeProductView";

    let payload = json!({
        "AcceptLanguage": "",
        "Id": ""
    });

    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=AWS242ServiceCatalogService.DescribeProductView' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "Id": ""
}'

echo '{
  "AcceptLanguage": "",
  "Id": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductView' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "Id": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductView'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "Id": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProductView")! 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 DescribeProvisionedProduct

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProduct

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "Id": "",
  "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=AWS242ServiceCatalogService.DescribeProvisionedProduct");

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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProduct" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:AcceptLanguage ""
                                                                                                                               :Id ""
                                                                                                                               :Name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProduct"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\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=AWS242ServiceCatalogService.DescribeProvisionedProduct"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\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=AWS242ServiceCatalogService.DescribeProvisionedProduct");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\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=AWS242ServiceCatalogService.DescribeProvisionedProduct"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\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: 52

{
  "AcceptLanguage": "",
  "Id": "",
  "Name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProduct")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProduct"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProduct")
  .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=AWS242ServiceCatalogService.DescribeProvisionedProduct")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  Id: '',
  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=AWS242ServiceCatalogService.DescribeProvisionedProduct');
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=AWS242ServiceCatalogService.DescribeProvisionedProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', Id: '', Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProduct';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","Id":"","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=AWS242ServiceCatalogService.DescribeProvisionedProduct',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "Id": "",\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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProduct")
  .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({AcceptLanguage: '', Id: '', Name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AcceptLanguage: '', Id: '', 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=AWS242ServiceCatalogService.DescribeProvisionedProduct');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  Id: '',
  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=AWS242ServiceCatalogService.DescribeProvisionedProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', Id: '', 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=AWS242ServiceCatalogService.DescribeProvisionedProduct';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","Id":"","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 = @{ @"AcceptLanguage": @"",
                              @"Id": @"",
                              @"Name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProduct"]
                                                       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=AWS242ServiceCatalogService.DescribeProvisionedProduct" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProduct",
  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([
    'AcceptLanguage' => '',
    'Id' => '',
    '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=AWS242ServiceCatalogService.DescribeProvisionedProduct', [
  'body' => '{
  "AcceptLanguage": "",
  "Id": "",
  "Name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProduct');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'Id' => '',
  'Name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'Id' => '',
  'Name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProduct');
$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=AWS242ServiceCatalogService.DescribeProvisionedProduct' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "Id": "",
  "Name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProduct' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "Id": "",
  "Name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\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=AWS242ServiceCatalogService.DescribeProvisionedProduct"

payload = {
    "AcceptLanguage": "",
    "Id": "",
    "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=AWS242ServiceCatalogService.DescribeProvisionedProduct"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\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=AWS242ServiceCatalogService.DescribeProvisionedProduct")

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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\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=AWS242ServiceCatalogService.DescribeProvisionedProduct";

    let payload = json!({
        "AcceptLanguage": "",
        "Id": "",
        "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=AWS242ServiceCatalogService.DescribeProvisionedProduct' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "Id": "",
  "Name": ""
}'

echo '{
  "AcceptLanguage": "",
  "Id": "",
  "Name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProduct' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "Id": "",\n  "Name": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProduct'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "Id": "",
  "Name": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProduct")! 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 DescribeProvisionedProductPlan

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProductPlan

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "PlanId": "",
  "PageSize": "",
  "PageToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProductPlan");

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  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProductPlan" {:headers {:x-amz-target ""}
                                                                                                                     :content-type :json
                                                                                                                     :form-params {:AcceptLanguage ""
                                                                                                                                   :PlanId ""
                                                                                                                                   :PageSize ""
                                                                                                                                   :PageToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProductPlan"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.DescribeProvisionedProductPlan"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.DescribeProvisionedProductPlan");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProductPlan"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 79

{
  "AcceptLanguage": "",
  "PlanId": "",
  "PageSize": "",
  "PageToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProductPlan")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProductPlan"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProductPlan")
  .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=AWS242ServiceCatalogService.DescribeProvisionedProductPlan")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  PlanId: '',
  PageSize: '',
  PageToken: ''
});

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=AWS242ServiceCatalogService.DescribeProvisionedProductPlan');
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=AWS242ServiceCatalogService.DescribeProvisionedProductPlan',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', PlanId: '', PageSize: '', PageToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProductPlan';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PlanId":"","PageSize":"","PageToken":""}'
};

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=AWS242ServiceCatalogService.DescribeProvisionedProductPlan',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "PlanId": "",\n  "PageSize": "",\n  "PageToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProductPlan")
  .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({AcceptLanguage: '', PlanId: '', PageSize: '', PageToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProductPlan',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AcceptLanguage: '', PlanId: '', PageSize: '', PageToken: ''},
  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=AWS242ServiceCatalogService.DescribeProvisionedProductPlan');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  PlanId: '',
  PageSize: '',
  PageToken: ''
});

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=AWS242ServiceCatalogService.DescribeProvisionedProductPlan',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', PlanId: '', PageSize: '', PageToken: ''}
};

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=AWS242ServiceCatalogService.DescribeProvisionedProductPlan';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PlanId":"","PageSize":"","PageToken":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"PlanId": @"",
                              @"PageSize": @"",
                              @"PageToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProductPlan"]
                                                       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=AWS242ServiceCatalogService.DescribeProvisionedProductPlan" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProductPlan",
  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([
    'AcceptLanguage' => '',
    'PlanId' => '',
    'PageSize' => '',
    'PageToken' => ''
  ]),
  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=AWS242ServiceCatalogService.DescribeProvisionedProductPlan', [
  'body' => '{
  "AcceptLanguage": "",
  "PlanId": "",
  "PageSize": "",
  "PageToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProductPlan');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'PlanId' => '',
  'PageSize' => '',
  'PageToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'PlanId' => '',
  'PageSize' => '',
  'PageToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProductPlan');
$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=AWS242ServiceCatalogService.DescribeProvisionedProductPlan' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PlanId": "",
  "PageSize": "",
  "PageToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProductPlan' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PlanId": "",
  "PageSize": "",
  "PageToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.DescribeProvisionedProductPlan"

payload = {
    "AcceptLanguage": "",
    "PlanId": "",
    "PageSize": "",
    "PageToken": ""
}
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=AWS242ServiceCatalogService.DescribeProvisionedProductPlan"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.DescribeProvisionedProductPlan")

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  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.DescribeProvisionedProductPlan";

    let payload = json!({
        "AcceptLanguage": "",
        "PlanId": "",
        "PageSize": "",
        "PageToken": ""
    });

    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=AWS242ServiceCatalogService.DescribeProvisionedProductPlan' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "PlanId": "",
  "PageSize": "",
  "PageToken": ""
}'

echo '{
  "AcceptLanguage": "",
  "PlanId": "",
  "PageSize": "",
  "PageToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProductPlan' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "PlanId": "",\n  "PageSize": "",\n  "PageToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProductPlan'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "PlanId": "",
  "PageSize": "",
  "PageToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisionedProductPlan")! 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 DescribeProvisioningArtifact

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningArtifact

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "ProvisioningArtifactId": "",
  "ProductId": "",
  "ProvisioningArtifactName": "",
  "ProductName": "",
  "Verbose": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningArtifact");

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  \"AcceptLanguage\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"ProductName\": \"\",\n  \"Verbose\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningArtifact" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:AcceptLanguage ""
                                                                                                                                 :ProvisioningArtifactId ""
                                                                                                                                 :ProductId ""
                                                                                                                                 :ProvisioningArtifactName ""
                                                                                                                                 :ProductName ""
                                                                                                                                 :Verbose ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningArtifact"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"ProductName\": \"\",\n  \"Verbose\": \"\"\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=AWS242ServiceCatalogService.DescribeProvisioningArtifact"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"ProductName\": \"\",\n  \"Verbose\": \"\"\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=AWS242ServiceCatalogService.DescribeProvisioningArtifact");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"ProductName\": \"\",\n  \"Verbose\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningArtifact"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"ProductName\": \"\",\n  \"Verbose\": \"\"\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: 149

{
  "AcceptLanguage": "",
  "ProvisioningArtifactId": "",
  "ProductId": "",
  "ProvisioningArtifactName": "",
  "ProductName": "",
  "Verbose": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningArtifact")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"ProductName\": \"\",\n  \"Verbose\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningArtifact"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"ProductName\": \"\",\n  \"Verbose\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"ProductName\": \"\",\n  \"Verbose\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningArtifact")
  .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=AWS242ServiceCatalogService.DescribeProvisioningArtifact")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"ProductName\": \"\",\n  \"Verbose\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  ProvisioningArtifactId: '',
  ProductId: '',
  ProvisioningArtifactName: '',
  ProductName: '',
  Verbose: ''
});

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=AWS242ServiceCatalogService.DescribeProvisioningArtifact');
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=AWS242ServiceCatalogService.DescribeProvisioningArtifact',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    ProvisioningArtifactId: '',
    ProductId: '',
    ProvisioningArtifactName: '',
    ProductName: '',
    Verbose: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningArtifact';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProvisioningArtifactId":"","ProductId":"","ProvisioningArtifactName":"","ProductName":"","Verbose":""}'
};

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=AWS242ServiceCatalogService.DescribeProvisioningArtifact',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "ProvisioningArtifactId": "",\n  "ProductId": "",\n  "ProvisioningArtifactName": "",\n  "ProductName": "",\n  "Verbose": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"ProductName\": \"\",\n  \"Verbose\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningArtifact")
  .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({
  AcceptLanguage: '',
  ProvisioningArtifactId: '',
  ProductId: '',
  ProvisioningArtifactName: '',
  ProductName: '',
  Verbose: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningArtifact',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AcceptLanguage: '',
    ProvisioningArtifactId: '',
    ProductId: '',
    ProvisioningArtifactName: '',
    ProductName: '',
    Verbose: ''
  },
  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=AWS242ServiceCatalogService.DescribeProvisioningArtifact');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  ProvisioningArtifactId: '',
  ProductId: '',
  ProvisioningArtifactName: '',
  ProductName: '',
  Verbose: ''
});

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=AWS242ServiceCatalogService.DescribeProvisioningArtifact',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    ProvisioningArtifactId: '',
    ProductId: '',
    ProvisioningArtifactName: '',
    ProductName: '',
    Verbose: ''
  }
};

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=AWS242ServiceCatalogService.DescribeProvisioningArtifact';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProvisioningArtifactId":"","ProductId":"","ProvisioningArtifactName":"","ProductName":"","Verbose":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"ProvisioningArtifactId": @"",
                              @"ProductId": @"",
                              @"ProvisioningArtifactName": @"",
                              @"ProductName": @"",
                              @"Verbose": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningArtifact"]
                                                       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=AWS242ServiceCatalogService.DescribeProvisioningArtifact" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"ProductName\": \"\",\n  \"Verbose\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningArtifact",
  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([
    'AcceptLanguage' => '',
    'ProvisioningArtifactId' => '',
    'ProductId' => '',
    'ProvisioningArtifactName' => '',
    'ProductName' => '',
    'Verbose' => ''
  ]),
  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=AWS242ServiceCatalogService.DescribeProvisioningArtifact', [
  'body' => '{
  "AcceptLanguage": "",
  "ProvisioningArtifactId": "",
  "ProductId": "",
  "ProvisioningArtifactName": "",
  "ProductName": "",
  "Verbose": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningArtifact');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'ProvisioningArtifactId' => '',
  'ProductId' => '',
  'ProvisioningArtifactName' => '',
  'ProductName' => '',
  'Verbose' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'ProvisioningArtifactId' => '',
  'ProductId' => '',
  'ProvisioningArtifactName' => '',
  'ProductName' => '',
  'Verbose' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningArtifact');
$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=AWS242ServiceCatalogService.DescribeProvisioningArtifact' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ProvisioningArtifactId": "",
  "ProductId": "",
  "ProvisioningArtifactName": "",
  "ProductName": "",
  "Verbose": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningArtifact' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ProvisioningArtifactId": "",
  "ProductId": "",
  "ProvisioningArtifactName": "",
  "ProductName": "",
  "Verbose": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"ProductName\": \"\",\n  \"Verbose\": \"\"\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=AWS242ServiceCatalogService.DescribeProvisioningArtifact"

payload = {
    "AcceptLanguage": "",
    "ProvisioningArtifactId": "",
    "ProductId": "",
    "ProvisioningArtifactName": "",
    "ProductName": "",
    "Verbose": ""
}
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=AWS242ServiceCatalogService.DescribeProvisioningArtifact"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"ProductName\": \"\",\n  \"Verbose\": \"\"\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=AWS242ServiceCatalogService.DescribeProvisioningArtifact")

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  \"AcceptLanguage\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"ProductName\": \"\",\n  \"Verbose\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"ProductName\": \"\",\n  \"Verbose\": \"\"\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=AWS242ServiceCatalogService.DescribeProvisioningArtifact";

    let payload = json!({
        "AcceptLanguage": "",
        "ProvisioningArtifactId": "",
        "ProductId": "",
        "ProvisioningArtifactName": "",
        "ProductName": "",
        "Verbose": ""
    });

    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=AWS242ServiceCatalogService.DescribeProvisioningArtifact' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "ProvisioningArtifactId": "",
  "ProductId": "",
  "ProvisioningArtifactName": "",
  "ProductName": "",
  "Verbose": ""
}'

echo '{
  "AcceptLanguage": "",
  "ProvisioningArtifactId": "",
  "ProductId": "",
  "ProvisioningArtifactName": "",
  "ProductName": "",
  "Verbose": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningArtifact' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "ProvisioningArtifactId": "",\n  "ProductId": "",\n  "ProvisioningArtifactName": "",\n  "ProductName": "",\n  "Verbose": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningArtifact'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "ProvisioningArtifactId": "",
  "ProductId": "",
  "ProvisioningArtifactName": "",
  "ProductName": "",
  "Verbose": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningArtifact")! 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 DescribeProvisioningParameters

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningParameters

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningArtifactName": "",
  "PathId": "",
  "PathName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningParameters");

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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningParameters" {:headers {:x-amz-target ""}
                                                                                                                     :content-type :json
                                                                                                                     :form-params {:AcceptLanguage ""
                                                                                                                                   :ProductId ""
                                                                                                                                   :ProductName ""
                                                                                                                                   :ProvisioningArtifactId ""
                                                                                                                                   :ProvisioningArtifactName ""
                                                                                                                                   :PathId ""
                                                                                                                                   :PathName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningParameters"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\"\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=AWS242ServiceCatalogService.DescribeProvisioningParameters"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\"\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=AWS242ServiceCatalogService.DescribeProvisioningParameters");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningParameters"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\"\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: 166

{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningArtifactName": "",
  "PathId": "",
  "PathName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningParameters")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningParameters"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningParameters")
  .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=AWS242ServiceCatalogService.DescribeProvisioningParameters")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  ProductId: '',
  ProductName: '',
  ProvisioningArtifactId: '',
  ProvisioningArtifactName: '',
  PathId: '',
  PathName: ''
});

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=AWS242ServiceCatalogService.DescribeProvisioningParameters');
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=AWS242ServiceCatalogService.DescribeProvisioningParameters',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    ProductId: '',
    ProductName: '',
    ProvisioningArtifactId: '',
    ProvisioningArtifactName: '',
    PathId: '',
    PathName: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningParameters';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProductId":"","ProductName":"","ProvisioningArtifactId":"","ProvisioningArtifactName":"","PathId":"","PathName":""}'
};

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=AWS242ServiceCatalogService.DescribeProvisioningParameters',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "ProductId": "",\n  "ProductName": "",\n  "ProvisioningArtifactId": "",\n  "ProvisioningArtifactName": "",\n  "PathId": "",\n  "PathName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningParameters")
  .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({
  AcceptLanguage: '',
  ProductId: '',
  ProductName: '',
  ProvisioningArtifactId: '',
  ProvisioningArtifactName: '',
  PathId: '',
  PathName: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningParameters',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AcceptLanguage: '',
    ProductId: '',
    ProductName: '',
    ProvisioningArtifactId: '',
    ProvisioningArtifactName: '',
    PathId: '',
    PathName: ''
  },
  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=AWS242ServiceCatalogService.DescribeProvisioningParameters');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  ProductId: '',
  ProductName: '',
  ProvisioningArtifactId: '',
  ProvisioningArtifactName: '',
  PathId: '',
  PathName: ''
});

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=AWS242ServiceCatalogService.DescribeProvisioningParameters',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    ProductId: '',
    ProductName: '',
    ProvisioningArtifactId: '',
    ProvisioningArtifactName: '',
    PathId: '',
    PathName: ''
  }
};

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=AWS242ServiceCatalogService.DescribeProvisioningParameters';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProductId":"","ProductName":"","ProvisioningArtifactId":"","ProvisioningArtifactName":"","PathId":"","PathName":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"ProductId": @"",
                              @"ProductName": @"",
                              @"ProvisioningArtifactId": @"",
                              @"ProvisioningArtifactName": @"",
                              @"PathId": @"",
                              @"PathName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningParameters"]
                                                       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=AWS242ServiceCatalogService.DescribeProvisioningParameters" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningParameters",
  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([
    'AcceptLanguage' => '',
    'ProductId' => '',
    'ProductName' => '',
    'ProvisioningArtifactId' => '',
    'ProvisioningArtifactName' => '',
    'PathId' => '',
    'PathName' => ''
  ]),
  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=AWS242ServiceCatalogService.DescribeProvisioningParameters', [
  'body' => '{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningArtifactName": "",
  "PathId": "",
  "PathName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningParameters');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'ProductId' => '',
  'ProductName' => '',
  'ProvisioningArtifactId' => '',
  'ProvisioningArtifactName' => '',
  'PathId' => '',
  'PathName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'ProductId' => '',
  'ProductName' => '',
  'ProvisioningArtifactId' => '',
  'ProvisioningArtifactName' => '',
  'PathId' => '',
  'PathName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningParameters');
$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=AWS242ServiceCatalogService.DescribeProvisioningParameters' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningArtifactName": "",
  "PathId": "",
  "PathName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningParameters' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningArtifactName": "",
  "PathId": "",
  "PathName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\"\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=AWS242ServiceCatalogService.DescribeProvisioningParameters"

payload = {
    "AcceptLanguage": "",
    "ProductId": "",
    "ProductName": "",
    "ProvisioningArtifactId": "",
    "ProvisioningArtifactName": "",
    "PathId": "",
    "PathName": ""
}
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=AWS242ServiceCatalogService.DescribeProvisioningParameters"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\"\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=AWS242ServiceCatalogService.DescribeProvisioningParameters")

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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\"\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=AWS242ServiceCatalogService.DescribeProvisioningParameters";

    let payload = json!({
        "AcceptLanguage": "",
        "ProductId": "",
        "ProductName": "",
        "ProvisioningArtifactId": "",
        "ProvisioningArtifactName": "",
        "PathId": "",
        "PathName": ""
    });

    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=AWS242ServiceCatalogService.DescribeProvisioningParameters' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningArtifactName": "",
  "PathId": "",
  "PathName": ""
}'

echo '{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningArtifactName": "",
  "PathId": "",
  "PathName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningParameters' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "ProductId": "",\n  "ProductName": "",\n  "ProvisioningArtifactId": "",\n  "ProvisioningArtifactName": "",\n  "PathId": "",\n  "PathName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningParameters'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "ProductId": "",
  "ProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningArtifactName": "",
  "PathId": "",
  "PathName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeProvisioningParameters")! 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 DescribeRecord

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeRecord

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "Id": "",
  "PageToken": "",
  "PageSize": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeRecord");

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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeRecord" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:AcceptLanguage ""
                                                                                                                   :Id ""
                                                                                                                   :PageToken ""
                                                                                                                   :PageSize ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeRecord"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.DescribeRecord"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.DescribeRecord");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeRecord"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 75

{
  "AcceptLanguage": "",
  "Id": "",
  "PageToken": "",
  "PageSize": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeRecord")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeRecord"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeRecord")
  .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=AWS242ServiceCatalogService.DescribeRecord")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  Id: '',
  PageToken: '',
  PageSize: ''
});

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=AWS242ServiceCatalogService.DescribeRecord');
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=AWS242ServiceCatalogService.DescribeRecord',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', Id: '', PageToken: '', PageSize: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeRecord';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","Id":"","PageToken":"","PageSize":""}'
};

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=AWS242ServiceCatalogService.DescribeRecord',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "Id": "",\n  "PageToken": "",\n  "PageSize": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeRecord")
  .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({AcceptLanguage: '', Id: '', PageToken: '', PageSize: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeRecord',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AcceptLanguage: '', Id: '', PageToken: '', PageSize: ''},
  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=AWS242ServiceCatalogService.DescribeRecord');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  Id: '',
  PageToken: '',
  PageSize: ''
});

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=AWS242ServiceCatalogService.DescribeRecord',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', Id: '', PageToken: '', PageSize: ''}
};

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=AWS242ServiceCatalogService.DescribeRecord';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","Id":"","PageToken":"","PageSize":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"Id": @"",
                              @"PageToken": @"",
                              @"PageSize": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeRecord"]
                                                       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=AWS242ServiceCatalogService.DescribeRecord" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeRecord",
  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([
    'AcceptLanguage' => '',
    'Id' => '',
    'PageToken' => '',
    'PageSize' => ''
  ]),
  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=AWS242ServiceCatalogService.DescribeRecord', [
  'body' => '{
  "AcceptLanguage": "",
  "Id": "",
  "PageToken": "",
  "PageSize": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeRecord');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'Id' => '',
  'PageToken' => '',
  'PageSize' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'Id' => '',
  'PageToken' => '',
  'PageSize' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeRecord');
$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=AWS242ServiceCatalogService.DescribeRecord' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "Id": "",
  "PageToken": "",
  "PageSize": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeRecord' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "Id": "",
  "PageToken": "",
  "PageSize": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.DescribeRecord"

payload = {
    "AcceptLanguage": "",
    "Id": "",
    "PageToken": "",
    "PageSize": ""
}
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=AWS242ServiceCatalogService.DescribeRecord"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.DescribeRecord")

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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.DescribeRecord";

    let payload = json!({
        "AcceptLanguage": "",
        "Id": "",
        "PageToken": "",
        "PageSize": ""
    });

    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=AWS242ServiceCatalogService.DescribeRecord' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "Id": "",
  "PageToken": "",
  "PageSize": ""
}'

echo '{
  "AcceptLanguage": "",
  "Id": "",
  "PageToken": "",
  "PageSize": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeRecord' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "Id": "",\n  "PageToken": "",\n  "PageSize": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeRecord'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "Id": "",
  "PageToken": "",
  "PageSize": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeRecord")! 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 DescribeServiceAction

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceAction

HEADERS

X-Amz-Target

BODY json

{
  "Id": "",
  "AcceptLanguage": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceAction");

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  \"Id\": \"\",\n  \"AcceptLanguage\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceAction" {:headers {:x-amz-target ""}
                                                                                                            :content-type :json
                                                                                                            :form-params {:Id ""
                                                                                                                          :AcceptLanguage ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceAction"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Id\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.DescribeServiceAction"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Id\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.DescribeServiceAction");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Id\": \"\",\n  \"AcceptLanguage\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceAction"

	payload := strings.NewReader("{\n  \"Id\": \"\",\n  \"AcceptLanguage\": \"\"\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: 38

{
  "Id": "",
  "AcceptLanguage": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceAction")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Id\": \"\",\n  \"AcceptLanguage\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceAction"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Id\": \"\",\n  \"AcceptLanguage\": \"\"\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  \"Id\": \"\",\n  \"AcceptLanguage\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceAction")
  .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=AWS242ServiceCatalogService.DescribeServiceAction")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Id\": \"\",\n  \"AcceptLanguage\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Id: '',
  AcceptLanguage: ''
});

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=AWS242ServiceCatalogService.DescribeServiceAction');
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=AWS242ServiceCatalogService.DescribeServiceAction',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Id: '', AcceptLanguage: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceAction';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Id":"","AcceptLanguage":""}'
};

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=AWS242ServiceCatalogService.DescribeServiceAction',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Id": "",\n  "AcceptLanguage": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Id\": \"\",\n  \"AcceptLanguage\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceAction")
  .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({Id: '', AcceptLanguage: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceAction',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Id: '', AcceptLanguage: ''},
  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=AWS242ServiceCatalogService.DescribeServiceAction');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Id: '',
  AcceptLanguage: ''
});

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=AWS242ServiceCatalogService.DescribeServiceAction',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Id: '', AcceptLanguage: ''}
};

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=AWS242ServiceCatalogService.DescribeServiceAction';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Id":"","AcceptLanguage":""}'
};

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 = @{ @"Id": @"",
                              @"AcceptLanguage": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceAction"]
                                                       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=AWS242ServiceCatalogService.DescribeServiceAction" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Id\": \"\",\n  \"AcceptLanguage\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceAction",
  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([
    'Id' => '',
    'AcceptLanguage' => ''
  ]),
  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=AWS242ServiceCatalogService.DescribeServiceAction', [
  'body' => '{
  "Id": "",
  "AcceptLanguage": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceAction');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Id' => '',
  'AcceptLanguage' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Id' => '',
  'AcceptLanguage' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceAction');
$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=AWS242ServiceCatalogService.DescribeServiceAction' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Id": "",
  "AcceptLanguage": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceAction' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Id": "",
  "AcceptLanguage": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Id\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.DescribeServiceAction"

payload = {
    "Id": "",
    "AcceptLanguage": ""
}
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=AWS242ServiceCatalogService.DescribeServiceAction"

payload <- "{\n  \"Id\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.DescribeServiceAction")

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  \"Id\": \"\",\n  \"AcceptLanguage\": \"\"\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  \"Id\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.DescribeServiceAction";

    let payload = json!({
        "Id": "",
        "AcceptLanguage": ""
    });

    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=AWS242ServiceCatalogService.DescribeServiceAction' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Id": "",
  "AcceptLanguage": ""
}'

echo '{
  "Id": "",
  "AcceptLanguage": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceAction' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Id": "",\n  "AcceptLanguage": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceAction'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Id": "",
  "AcceptLanguage": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceAction")! 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 DescribeServiceActionExecutionParameters

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters

HEADERS

X-Amz-Target

BODY json

{
  "ProvisionedProductId": "",
  "ServiceActionId": "",
  "AcceptLanguage": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters");

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  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters" {:headers {:x-amz-target ""}
                                                                                                                               :content-type :json
                                                                                                                               :form-params {:ProvisionedProductId ""
                                                                                                                                             :ServiceActionId ""
                                                                                                                                             :AcceptLanguage ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters"

	payload := strings.NewReader("{\n  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 81

{
  "ProvisionedProductId": "",
  "ServiceActionId": "",
  "AcceptLanguage": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\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  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters")
  .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=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ProvisionedProductId: '',
  ServiceActionId: '',
  AcceptLanguage: ''
});

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=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters');
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=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ProvisionedProductId: '', ServiceActionId: '', AcceptLanguage: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ProvisionedProductId":"","ServiceActionId":"","AcceptLanguage":""}'
};

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=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ProvisionedProductId": "",\n  "ServiceActionId": "",\n  "AcceptLanguage": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters")
  .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({ProvisionedProductId: '', ServiceActionId: '', AcceptLanguage: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ProvisionedProductId: '', ServiceActionId: '', AcceptLanguage: ''},
  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=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ProvisionedProductId: '',
  ServiceActionId: '',
  AcceptLanguage: ''
});

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=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ProvisionedProductId: '', ServiceActionId: '', AcceptLanguage: ''}
};

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=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ProvisionedProductId":"","ServiceActionId":"","AcceptLanguage":""}'
};

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 = @{ @"ProvisionedProductId": @"",
                              @"ServiceActionId": @"",
                              @"AcceptLanguage": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters"]
                                                       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=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters",
  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([
    'ProvisionedProductId' => '',
    'ServiceActionId' => '',
    'AcceptLanguage' => ''
  ]),
  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=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters', [
  'body' => '{
  "ProvisionedProductId": "",
  "ServiceActionId": "",
  "AcceptLanguage": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ProvisionedProductId' => '',
  'ServiceActionId' => '',
  'AcceptLanguage' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ProvisionedProductId' => '',
  'ServiceActionId' => '',
  'AcceptLanguage' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters');
$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=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ProvisionedProductId": "",
  "ServiceActionId": "",
  "AcceptLanguage": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ProvisionedProductId": "",
  "ServiceActionId": "",
  "AcceptLanguage": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters"

payload = {
    "ProvisionedProductId": "",
    "ServiceActionId": "",
    "AcceptLanguage": ""
}
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=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters"

payload <- "{\n  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters")

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  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\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  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters";

    let payload = json!({
        "ProvisionedProductId": "",
        "ServiceActionId": "",
        "AcceptLanguage": ""
    });

    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=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ProvisionedProductId": "",
  "ServiceActionId": "",
  "AcceptLanguage": ""
}'

echo '{
  "ProvisionedProductId": "",
  "ServiceActionId": "",
  "AcceptLanguage": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ProvisionedProductId": "",\n  "ServiceActionId": "",\n  "AcceptLanguage": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ProvisionedProductId": "",
  "ServiceActionId": "",
  "AcceptLanguage": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters")! 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 DescribeTagOption

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeTagOption

HEADERS

X-Amz-Target

BODY json

{
  "Id": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeTagOption");

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  \"Id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeTagOption" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:Id ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeTagOption"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Id\": \"\"\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=AWS242ServiceCatalogService.DescribeTagOption"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Id\": \"\"\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=AWS242ServiceCatalogService.DescribeTagOption");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeTagOption"

	payload := strings.NewReader("{\n  \"Id\": \"\"\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: 14

{
  "Id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeTagOption")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeTagOption"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Id\": \"\"\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  \"Id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeTagOption")
  .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=AWS242ServiceCatalogService.DescribeTagOption")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Id: ''
});

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=AWS242ServiceCatalogService.DescribeTagOption');
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=AWS242ServiceCatalogService.DescribeTagOption',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeTagOption';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Id":""}'
};

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=AWS242ServiceCatalogService.DescribeTagOption',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Id": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeTagOption")
  .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({Id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeTagOption',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Id: ''},
  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=AWS242ServiceCatalogService.DescribeTagOption');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Id: ''
});

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=AWS242ServiceCatalogService.DescribeTagOption',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Id: ''}
};

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=AWS242ServiceCatalogService.DescribeTagOption';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Id":""}'
};

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 = @{ @"Id": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeTagOption"]
                                                       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=AWS242ServiceCatalogService.DescribeTagOption" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Id\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeTagOption",
  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([
    'Id' => ''
  ]),
  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=AWS242ServiceCatalogService.DescribeTagOption', [
  'body' => '{
  "Id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeTagOption');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Id' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeTagOption');
$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=AWS242ServiceCatalogService.DescribeTagOption' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Id": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeTagOption' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Id": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Id\": \"\"\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=AWS242ServiceCatalogService.DescribeTagOption"

payload = { "Id": "" }
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=AWS242ServiceCatalogService.DescribeTagOption"

payload <- "{\n  \"Id\": \"\"\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=AWS242ServiceCatalogService.DescribeTagOption")

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  \"Id\": \"\"\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  \"Id\": \"\"\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=AWS242ServiceCatalogService.DescribeTagOption";

    let payload = json!({"Id": ""});

    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=AWS242ServiceCatalogService.DescribeTagOption' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Id": ""
}'

echo '{
  "Id": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeTagOption' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Id": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeTagOption'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["Id": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DescribeTagOption")! 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 DisableAWSOrganizationsAccess

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess

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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess");

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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess" {:headers {:x-amz-target ""}
                                                                                                                    :content-type :json})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess"
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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess"),
    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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess");
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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess"

	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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess")
  .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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess"))
    .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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess")
  .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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess")
  .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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess');
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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess',
  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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess';
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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess',
  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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess")
  .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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess',
  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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess');

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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess',
  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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess';
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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess"]
                                                       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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess" 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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess",
  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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess');
$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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess');
$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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess' -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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess' -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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess"

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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess"

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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess")

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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess";

    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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{}'

echo '{}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess' \
  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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess'

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=AWS242ServiceCatalogService.DisableAWSOrganizationsAccess")! 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 DisassociateBudgetFromResource

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateBudgetFromResource

HEADERS

X-Amz-Target

BODY json

{
  "BudgetName": "",
  "ResourceId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateBudgetFromResource");

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  \"BudgetName\": \"\",\n  \"ResourceId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateBudgetFromResource" {:headers {:x-amz-target ""}
                                                                                                                     :content-type :json
                                                                                                                     :form-params {:BudgetName ""
                                                                                                                                   :ResourceId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateBudgetFromResource"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"BudgetName\": \"\",\n  \"ResourceId\": \"\"\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=AWS242ServiceCatalogService.DisassociateBudgetFromResource"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"BudgetName\": \"\",\n  \"ResourceId\": \"\"\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=AWS242ServiceCatalogService.DisassociateBudgetFromResource");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"BudgetName\": \"\",\n  \"ResourceId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateBudgetFromResource"

	payload := strings.NewReader("{\n  \"BudgetName\": \"\",\n  \"ResourceId\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 42

{
  "BudgetName": "",
  "ResourceId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateBudgetFromResource")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"BudgetName\": \"\",\n  \"ResourceId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateBudgetFromResource"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"BudgetName\": \"\",\n  \"ResourceId\": \"\"\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  \"BudgetName\": \"\",\n  \"ResourceId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateBudgetFromResource")
  .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=AWS242ServiceCatalogService.DisassociateBudgetFromResource")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"BudgetName\": \"\",\n  \"ResourceId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  BudgetName: '',
  ResourceId: ''
});

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=AWS242ServiceCatalogService.DisassociateBudgetFromResource');
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=AWS242ServiceCatalogService.DisassociateBudgetFromResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {BudgetName: '', ResourceId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateBudgetFromResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"BudgetName":"","ResourceId":""}'
};

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=AWS242ServiceCatalogService.DisassociateBudgetFromResource',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "BudgetName": "",\n  "ResourceId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"BudgetName\": \"\",\n  \"ResourceId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateBudgetFromResource")
  .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({BudgetName: '', ResourceId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateBudgetFromResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {BudgetName: '', ResourceId: ''},
  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=AWS242ServiceCatalogService.DisassociateBudgetFromResource');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  BudgetName: '',
  ResourceId: ''
});

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=AWS242ServiceCatalogService.DisassociateBudgetFromResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {BudgetName: '', ResourceId: ''}
};

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=AWS242ServiceCatalogService.DisassociateBudgetFromResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"BudgetName":"","ResourceId":""}'
};

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 = @{ @"BudgetName": @"",
                              @"ResourceId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateBudgetFromResource"]
                                                       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=AWS242ServiceCatalogService.DisassociateBudgetFromResource" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"BudgetName\": \"\",\n  \"ResourceId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateBudgetFromResource",
  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([
    'BudgetName' => '',
    'ResourceId' => ''
  ]),
  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=AWS242ServiceCatalogService.DisassociateBudgetFromResource', [
  'body' => '{
  "BudgetName": "",
  "ResourceId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateBudgetFromResource');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'BudgetName' => '',
  'ResourceId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'BudgetName' => '',
  'ResourceId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateBudgetFromResource');
$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=AWS242ServiceCatalogService.DisassociateBudgetFromResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "BudgetName": "",
  "ResourceId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateBudgetFromResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "BudgetName": "",
  "ResourceId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"BudgetName\": \"\",\n  \"ResourceId\": \"\"\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=AWS242ServiceCatalogService.DisassociateBudgetFromResource"

payload = {
    "BudgetName": "",
    "ResourceId": ""
}
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=AWS242ServiceCatalogService.DisassociateBudgetFromResource"

payload <- "{\n  \"BudgetName\": \"\",\n  \"ResourceId\": \"\"\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=AWS242ServiceCatalogService.DisassociateBudgetFromResource")

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  \"BudgetName\": \"\",\n  \"ResourceId\": \"\"\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  \"BudgetName\": \"\",\n  \"ResourceId\": \"\"\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=AWS242ServiceCatalogService.DisassociateBudgetFromResource";

    let payload = json!({
        "BudgetName": "",
        "ResourceId": ""
    });

    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=AWS242ServiceCatalogService.DisassociateBudgetFromResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "BudgetName": "",
  "ResourceId": ""
}'

echo '{
  "BudgetName": "",
  "ResourceId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateBudgetFromResource' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "BudgetName": "",\n  "ResourceId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateBudgetFromResource'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "BudgetName": "",
  "ResourceId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateBudgetFromResource")! 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 DisassociatePrincipalFromPortfolio

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PrincipalARN": "",
  "PrincipalType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio");

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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PrincipalARN\": \"\",\n  \"PrincipalType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio" {:headers {:x-amz-target ""}
                                                                                                                         :content-type :json
                                                                                                                         :form-params {:AcceptLanguage ""
                                                                                                                                       :PortfolioId ""
                                                                                                                                       :PrincipalARN ""
                                                                                                                                       :PrincipalType ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PrincipalARN\": \"\",\n  \"PrincipalType\": \"\"\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=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PrincipalARN\": \"\",\n  \"PrincipalType\": \"\"\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=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PrincipalARN\": \"\",\n  \"PrincipalType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PrincipalARN\": \"\",\n  \"PrincipalType\": \"\"\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: 92

{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PrincipalARN": "",
  "PrincipalType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PrincipalARN\": \"\",\n  \"PrincipalType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PrincipalARN\": \"\",\n  \"PrincipalType\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PrincipalARN\": \"\",\n  \"PrincipalType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio")
  .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=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PrincipalARN\": \"\",\n  \"PrincipalType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  PortfolioId: '',
  PrincipalARN: '',
  PrincipalType: ''
});

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=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio');
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=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', PortfolioId: '', PrincipalARN: '', PrincipalType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PortfolioId":"","PrincipalARN":"","PrincipalType":""}'
};

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=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "PortfolioId": "",\n  "PrincipalARN": "",\n  "PrincipalType": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PrincipalARN\": \"\",\n  \"PrincipalType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio")
  .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({AcceptLanguage: '', PortfolioId: '', PrincipalARN: '', PrincipalType: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AcceptLanguage: '', PortfolioId: '', PrincipalARN: '', PrincipalType: ''},
  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=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  PortfolioId: '',
  PrincipalARN: '',
  PrincipalType: ''
});

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=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', PortfolioId: '', PrincipalARN: '', PrincipalType: ''}
};

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=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PortfolioId":"","PrincipalARN":"","PrincipalType":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"PortfolioId": @"",
                              @"PrincipalARN": @"",
                              @"PrincipalType": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio"]
                                                       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=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PrincipalARN\": \"\",\n  \"PrincipalType\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio",
  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([
    'AcceptLanguage' => '',
    'PortfolioId' => '',
    'PrincipalARN' => '',
    'PrincipalType' => ''
  ]),
  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=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio', [
  'body' => '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PrincipalARN": "",
  "PrincipalType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'PortfolioId' => '',
  'PrincipalARN' => '',
  'PrincipalType' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'PortfolioId' => '',
  'PrincipalARN' => '',
  'PrincipalType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio');
$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=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PrincipalARN": "",
  "PrincipalType": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PrincipalARN": "",
  "PrincipalType": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PrincipalARN\": \"\",\n  \"PrincipalType\": \"\"\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=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio"

payload = {
    "AcceptLanguage": "",
    "PortfolioId": "",
    "PrincipalARN": "",
    "PrincipalType": ""
}
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=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PrincipalARN\": \"\",\n  \"PrincipalType\": \"\"\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=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio")

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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PrincipalARN\": \"\",\n  \"PrincipalType\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PrincipalARN\": \"\",\n  \"PrincipalType\": \"\"\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=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio";

    let payload = json!({
        "AcceptLanguage": "",
        "PortfolioId": "",
        "PrincipalARN": "",
        "PrincipalType": ""
    });

    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=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PrincipalARN": "",
  "PrincipalType": ""
}'

echo '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PrincipalARN": "",
  "PrincipalType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "PortfolioId": "",\n  "PrincipalARN": "",\n  "PrincipalType": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PrincipalARN": "",
  "PrincipalType": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio")! 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 DisassociateProductFromPortfolio

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateProductFromPortfolio

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "ProductId": "",
  "PortfolioId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateProductFromPortfolio");

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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PortfolioId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateProductFromPortfolio" {:headers {:x-amz-target ""}
                                                                                                                       :content-type :json
                                                                                                                       :form-params {:AcceptLanguage ""
                                                                                                                                     :ProductId ""
                                                                                                                                     :PortfolioId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateProductFromPortfolio"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PortfolioId\": \"\"\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=AWS242ServiceCatalogService.DisassociateProductFromPortfolio"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PortfolioId\": \"\"\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=AWS242ServiceCatalogService.DisassociateProductFromPortfolio");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PortfolioId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateProductFromPortfolio"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PortfolioId\": \"\"\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: 66

{
  "AcceptLanguage": "",
  "ProductId": "",
  "PortfolioId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateProductFromPortfolio")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PortfolioId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateProductFromPortfolio"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PortfolioId\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PortfolioId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateProductFromPortfolio")
  .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=AWS242ServiceCatalogService.DisassociateProductFromPortfolio")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PortfolioId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  ProductId: '',
  PortfolioId: ''
});

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=AWS242ServiceCatalogService.DisassociateProductFromPortfolio');
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=AWS242ServiceCatalogService.DisassociateProductFromPortfolio',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', ProductId: '', PortfolioId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateProductFromPortfolio';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProductId":"","PortfolioId":""}'
};

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=AWS242ServiceCatalogService.DisassociateProductFromPortfolio',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "ProductId": "",\n  "PortfolioId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PortfolioId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateProductFromPortfolio")
  .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({AcceptLanguage: '', ProductId: '', PortfolioId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateProductFromPortfolio',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AcceptLanguage: '', ProductId: '', PortfolioId: ''},
  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=AWS242ServiceCatalogService.DisassociateProductFromPortfolio');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  ProductId: '',
  PortfolioId: ''
});

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=AWS242ServiceCatalogService.DisassociateProductFromPortfolio',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', ProductId: '', PortfolioId: ''}
};

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=AWS242ServiceCatalogService.DisassociateProductFromPortfolio';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProductId":"","PortfolioId":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"ProductId": @"",
                              @"PortfolioId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateProductFromPortfolio"]
                                                       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=AWS242ServiceCatalogService.DisassociateProductFromPortfolio" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PortfolioId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateProductFromPortfolio",
  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([
    'AcceptLanguage' => '',
    'ProductId' => '',
    'PortfolioId' => ''
  ]),
  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=AWS242ServiceCatalogService.DisassociateProductFromPortfolio', [
  'body' => '{
  "AcceptLanguage": "",
  "ProductId": "",
  "PortfolioId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateProductFromPortfolio');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'ProductId' => '',
  'PortfolioId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'ProductId' => '',
  'PortfolioId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateProductFromPortfolio');
$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=AWS242ServiceCatalogService.DisassociateProductFromPortfolio' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ProductId": "",
  "PortfolioId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateProductFromPortfolio' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ProductId": "",
  "PortfolioId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PortfolioId\": \"\"\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=AWS242ServiceCatalogService.DisassociateProductFromPortfolio"

payload = {
    "AcceptLanguage": "",
    "ProductId": "",
    "PortfolioId": ""
}
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=AWS242ServiceCatalogService.DisassociateProductFromPortfolio"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PortfolioId\": \"\"\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=AWS242ServiceCatalogService.DisassociateProductFromPortfolio")

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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PortfolioId\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PortfolioId\": \"\"\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=AWS242ServiceCatalogService.DisassociateProductFromPortfolio";

    let payload = json!({
        "AcceptLanguage": "",
        "ProductId": "",
        "PortfolioId": ""
    });

    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=AWS242ServiceCatalogService.DisassociateProductFromPortfolio' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "ProductId": "",
  "PortfolioId": ""
}'

echo '{
  "AcceptLanguage": "",
  "ProductId": "",
  "PortfolioId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateProductFromPortfolio' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "ProductId": "",\n  "PortfolioId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateProductFromPortfolio'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "ProductId": "",
  "PortfolioId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateProductFromPortfolio")! 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 DisassociateServiceActionFromProvisioningArtifact

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact

HEADERS

X-Amz-Target

BODY json

{
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "ServiceActionId": "",
  "AcceptLanguage": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact");

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  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact" {:headers {:x-amz-target ""}
                                                                                                                                        :content-type :json
                                                                                                                                        :form-params {:ProductId ""
                                                                                                                                                      :ProvisioningArtifactId ""
                                                                                                                                                      :ServiceActionId ""
                                                                                                                                                      :AcceptLanguage ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact"

	payload := strings.NewReader("{\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\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: 102

{
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "ServiceActionId": "",
  "AcceptLanguage": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\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  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact")
  .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=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ProductId: '',
  ProvisioningArtifactId: '',
  ServiceActionId: '',
  AcceptLanguage: ''
});

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=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact');
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=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ProductId: '',
    ProvisioningArtifactId: '',
    ServiceActionId: '',
    AcceptLanguage: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ProductId":"","ProvisioningArtifactId":"","ServiceActionId":"","AcceptLanguage":""}'
};

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=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ProductId": "",\n  "ProvisioningArtifactId": "",\n  "ServiceActionId": "",\n  "AcceptLanguage": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact")
  .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({
  ProductId: '',
  ProvisioningArtifactId: '',
  ServiceActionId: '',
  AcceptLanguage: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ProductId: '',
    ProvisioningArtifactId: '',
    ServiceActionId: '',
    AcceptLanguage: ''
  },
  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=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ProductId: '',
  ProvisioningArtifactId: '',
  ServiceActionId: '',
  AcceptLanguage: ''
});

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=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ProductId: '',
    ProvisioningArtifactId: '',
    ServiceActionId: '',
    AcceptLanguage: ''
  }
};

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=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ProductId":"","ProvisioningArtifactId":"","ServiceActionId":"","AcceptLanguage":""}'
};

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 = @{ @"ProductId": @"",
                              @"ProvisioningArtifactId": @"",
                              @"ServiceActionId": @"",
                              @"AcceptLanguage": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact"]
                                                       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=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact",
  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([
    'ProductId' => '',
    'ProvisioningArtifactId' => '',
    'ServiceActionId' => '',
    'AcceptLanguage' => ''
  ]),
  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=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact', [
  'body' => '{
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "ServiceActionId": "",
  "AcceptLanguage": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ProductId' => '',
  'ProvisioningArtifactId' => '',
  'ServiceActionId' => '',
  'AcceptLanguage' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ProductId' => '',
  'ProvisioningArtifactId' => '',
  'ServiceActionId' => '',
  'AcceptLanguage' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact');
$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=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "ServiceActionId": "",
  "AcceptLanguage": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "ServiceActionId": "",
  "AcceptLanguage": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact"

payload = {
    "ProductId": "",
    "ProvisioningArtifactId": "",
    "ServiceActionId": "",
    "AcceptLanguage": ""
}
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=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact"

payload <- "{\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact")

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  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\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  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact";

    let payload = json!({
        "ProductId": "",
        "ProvisioningArtifactId": "",
        "ServiceActionId": "",
        "AcceptLanguage": ""
    });

    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=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "ServiceActionId": "",
  "AcceptLanguage": ""
}'

echo '{
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "ServiceActionId": "",
  "AcceptLanguage": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ProductId": "",\n  "ProvisioningArtifactId": "",\n  "ServiceActionId": "",\n  "AcceptLanguage": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "ServiceActionId": "",
  "AcceptLanguage": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact")! 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 DisassociateTagOptionFromResource

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateTagOptionFromResource

HEADERS

X-Amz-Target

BODY json

{
  "ResourceId": "",
  "TagOptionId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateTagOptionFromResource");

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  \"ResourceId\": \"\",\n  \"TagOptionId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateTagOptionFromResource" {:headers {:x-amz-target ""}
                                                                                                                        :content-type :json
                                                                                                                        :form-params {:ResourceId ""
                                                                                                                                      :TagOptionId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateTagOptionFromResource"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ResourceId\": \"\",\n  \"TagOptionId\": \"\"\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=AWS242ServiceCatalogService.DisassociateTagOptionFromResource"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ResourceId\": \"\",\n  \"TagOptionId\": \"\"\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=AWS242ServiceCatalogService.DisassociateTagOptionFromResource");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ResourceId\": \"\",\n  \"TagOptionId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateTagOptionFromResource"

	payload := strings.NewReader("{\n  \"ResourceId\": \"\",\n  \"TagOptionId\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 43

{
  "ResourceId": "",
  "TagOptionId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateTagOptionFromResource")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ResourceId\": \"\",\n  \"TagOptionId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateTagOptionFromResource"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ResourceId\": \"\",\n  \"TagOptionId\": \"\"\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  \"ResourceId\": \"\",\n  \"TagOptionId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateTagOptionFromResource")
  .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=AWS242ServiceCatalogService.DisassociateTagOptionFromResource")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ResourceId\": \"\",\n  \"TagOptionId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ResourceId: '',
  TagOptionId: ''
});

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=AWS242ServiceCatalogService.DisassociateTagOptionFromResource');
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=AWS242ServiceCatalogService.DisassociateTagOptionFromResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceId: '', TagOptionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateTagOptionFromResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceId":"","TagOptionId":""}'
};

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=AWS242ServiceCatalogService.DisassociateTagOptionFromResource',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ResourceId": "",\n  "TagOptionId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ResourceId\": \"\",\n  \"TagOptionId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateTagOptionFromResource")
  .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({ResourceId: '', TagOptionId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateTagOptionFromResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ResourceId: '', TagOptionId: ''},
  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=AWS242ServiceCatalogService.DisassociateTagOptionFromResource');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ResourceId: '',
  TagOptionId: ''
});

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=AWS242ServiceCatalogService.DisassociateTagOptionFromResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceId: '', TagOptionId: ''}
};

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=AWS242ServiceCatalogService.DisassociateTagOptionFromResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceId":"","TagOptionId":""}'
};

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 = @{ @"ResourceId": @"",
                              @"TagOptionId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateTagOptionFromResource"]
                                                       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=AWS242ServiceCatalogService.DisassociateTagOptionFromResource" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ResourceId\": \"\",\n  \"TagOptionId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateTagOptionFromResource",
  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([
    'ResourceId' => '',
    'TagOptionId' => ''
  ]),
  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=AWS242ServiceCatalogService.DisassociateTagOptionFromResource', [
  'body' => '{
  "ResourceId": "",
  "TagOptionId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateTagOptionFromResource');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ResourceId' => '',
  'TagOptionId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ResourceId' => '',
  'TagOptionId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateTagOptionFromResource');
$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=AWS242ServiceCatalogService.DisassociateTagOptionFromResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceId": "",
  "TagOptionId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateTagOptionFromResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceId": "",
  "TagOptionId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ResourceId\": \"\",\n  \"TagOptionId\": \"\"\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=AWS242ServiceCatalogService.DisassociateTagOptionFromResource"

payload = {
    "ResourceId": "",
    "TagOptionId": ""
}
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=AWS242ServiceCatalogService.DisassociateTagOptionFromResource"

payload <- "{\n  \"ResourceId\": \"\",\n  \"TagOptionId\": \"\"\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=AWS242ServiceCatalogService.DisassociateTagOptionFromResource")

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  \"ResourceId\": \"\",\n  \"TagOptionId\": \"\"\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  \"ResourceId\": \"\",\n  \"TagOptionId\": \"\"\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=AWS242ServiceCatalogService.DisassociateTagOptionFromResource";

    let payload = json!({
        "ResourceId": "",
        "TagOptionId": ""
    });

    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=AWS242ServiceCatalogService.DisassociateTagOptionFromResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceId": "",
  "TagOptionId": ""
}'

echo '{
  "ResourceId": "",
  "TagOptionId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateTagOptionFromResource' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ResourceId": "",\n  "TagOptionId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateTagOptionFromResource'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ResourceId": "",
  "TagOptionId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.DisassociateTagOptionFromResource")! 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 EnableAWSOrganizationsAccess

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess

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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess");

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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess"
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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess"),
    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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess");
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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess"

	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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess")
  .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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess"))
    .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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess")
  .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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess")
  .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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess');
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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess',
  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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess';
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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess',
  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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess")
  .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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess',
  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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess');

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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess',
  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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess';
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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess"]
                                                       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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess" 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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess",
  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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess');
$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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess');
$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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess' -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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess' -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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess"

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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess"

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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess")

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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess";

    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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{}'

echo '{}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess' \
  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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess'

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=AWS242ServiceCatalogService.EnableAWSOrganizationsAccess")! 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 ExecuteProvisionedProductPlan

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "PlanId": "",
  "IdempotencyToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan");

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  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"IdempotencyToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan" {:headers {:x-amz-target ""}
                                                                                                                    :content-type :json
                                                                                                                    :form-params {:AcceptLanguage ""
                                                                                                                                  :PlanId ""
                                                                                                                                  :IdempotencyToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"IdempotencyToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"IdempotencyToken\": \"\"\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: 68

{
  "AcceptLanguage": "",
  "PlanId": "",
  "IdempotencyToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"IdempotencyToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"IdempotencyToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"IdempotencyToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan")
  .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=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"IdempotencyToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  PlanId: '',
  IdempotencyToken: ''
});

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=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan');
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=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', PlanId: '', IdempotencyToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PlanId":"","IdempotencyToken":""}'
};

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=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "PlanId": "",\n  "IdempotencyToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"IdempotencyToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan")
  .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({AcceptLanguage: '', PlanId: '', IdempotencyToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AcceptLanguage: '', PlanId: '', IdempotencyToken: ''},
  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=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  PlanId: '',
  IdempotencyToken: ''
});

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=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', PlanId: '', IdempotencyToken: ''}
};

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=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PlanId":"","IdempotencyToken":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"PlanId": @"",
                              @"IdempotencyToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan"]
                                                       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=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"IdempotencyToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan",
  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([
    'AcceptLanguage' => '',
    'PlanId' => '',
    'IdempotencyToken' => ''
  ]),
  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=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan', [
  'body' => '{
  "AcceptLanguage": "",
  "PlanId": "",
  "IdempotencyToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'PlanId' => '',
  'IdempotencyToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'PlanId' => '',
  'IdempotencyToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan');
$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=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PlanId": "",
  "IdempotencyToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PlanId": "",
  "IdempotencyToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan"

payload = {
    "AcceptLanguage": "",
    "PlanId": "",
    "IdempotencyToken": ""
}
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=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan")

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  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"IdempotencyToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PlanId\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan";

    let payload = json!({
        "AcceptLanguage": "",
        "PlanId": "",
        "IdempotencyToken": ""
    });

    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=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "PlanId": "",
  "IdempotencyToken": ""
}'

echo '{
  "AcceptLanguage": "",
  "PlanId": "",
  "IdempotencyToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "PlanId": "",\n  "IdempotencyToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "PlanId": "",
  "IdempotencyToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductPlan")! 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 ExecuteProvisionedProductServiceAction

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction

HEADERS

X-Amz-Target

BODY json

{
  "ProvisionedProductId": "",
  "ServiceActionId": "",
  "ExecuteToken": "",
  "AcceptLanguage": "",
  "Parameters": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction");

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  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"ExecuteToken\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"Parameters\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction" {:headers {:x-amz-target ""}
                                                                                                                             :content-type :json
                                                                                                                             :form-params {:ProvisionedProductId ""
                                                                                                                                           :ServiceActionId ""
                                                                                                                                           :ExecuteToken ""
                                                                                                                                           :AcceptLanguage ""
                                                                                                                                           :Parameters ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"ExecuteToken\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"Parameters\": \"\"\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=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"ExecuteToken\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"Parameters\": \"\"\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=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"ExecuteToken\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"Parameters\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction"

	payload := strings.NewReader("{\n  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"ExecuteToken\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"Parameters\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 123

{
  "ProvisionedProductId": "",
  "ServiceActionId": "",
  "ExecuteToken": "",
  "AcceptLanguage": "",
  "Parameters": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"ExecuteToken\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"Parameters\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"ExecuteToken\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"Parameters\": \"\"\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  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"ExecuteToken\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"Parameters\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction")
  .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=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"ExecuteToken\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"Parameters\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ProvisionedProductId: '',
  ServiceActionId: '',
  ExecuteToken: '',
  AcceptLanguage: '',
  Parameters: ''
});

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=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction');
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=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ProvisionedProductId: '',
    ServiceActionId: '',
    ExecuteToken: '',
    AcceptLanguage: '',
    Parameters: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ProvisionedProductId":"","ServiceActionId":"","ExecuteToken":"","AcceptLanguage":"","Parameters":""}'
};

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=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ProvisionedProductId": "",\n  "ServiceActionId": "",\n  "ExecuteToken": "",\n  "AcceptLanguage": "",\n  "Parameters": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"ExecuteToken\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"Parameters\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction")
  .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({
  ProvisionedProductId: '',
  ServiceActionId: '',
  ExecuteToken: '',
  AcceptLanguage: '',
  Parameters: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ProvisionedProductId: '',
    ServiceActionId: '',
    ExecuteToken: '',
    AcceptLanguage: '',
    Parameters: ''
  },
  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=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ProvisionedProductId: '',
  ServiceActionId: '',
  ExecuteToken: '',
  AcceptLanguage: '',
  Parameters: ''
});

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=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ProvisionedProductId: '',
    ServiceActionId: '',
    ExecuteToken: '',
    AcceptLanguage: '',
    Parameters: ''
  }
};

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=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ProvisionedProductId":"","ServiceActionId":"","ExecuteToken":"","AcceptLanguage":"","Parameters":""}'
};

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 = @{ @"ProvisionedProductId": @"",
                              @"ServiceActionId": @"",
                              @"ExecuteToken": @"",
                              @"AcceptLanguage": @"",
                              @"Parameters": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction"]
                                                       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=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"ExecuteToken\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"Parameters\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction",
  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([
    'ProvisionedProductId' => '',
    'ServiceActionId' => '',
    'ExecuteToken' => '',
    'AcceptLanguage' => '',
    'Parameters' => ''
  ]),
  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=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction', [
  'body' => '{
  "ProvisionedProductId": "",
  "ServiceActionId": "",
  "ExecuteToken": "",
  "AcceptLanguage": "",
  "Parameters": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ProvisionedProductId' => '',
  'ServiceActionId' => '',
  'ExecuteToken' => '',
  'AcceptLanguage' => '',
  'Parameters' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ProvisionedProductId' => '',
  'ServiceActionId' => '',
  'ExecuteToken' => '',
  'AcceptLanguage' => '',
  'Parameters' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction');
$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=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ProvisionedProductId": "",
  "ServiceActionId": "",
  "ExecuteToken": "",
  "AcceptLanguage": "",
  "Parameters": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ProvisionedProductId": "",
  "ServiceActionId": "",
  "ExecuteToken": "",
  "AcceptLanguage": "",
  "Parameters": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"ExecuteToken\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"Parameters\": \"\"\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=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction"

payload = {
    "ProvisionedProductId": "",
    "ServiceActionId": "",
    "ExecuteToken": "",
    "AcceptLanguage": "",
    "Parameters": ""
}
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=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction"

payload <- "{\n  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"ExecuteToken\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"Parameters\": \"\"\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=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction")

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  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"ExecuteToken\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"Parameters\": \"\"\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  \"ProvisionedProductId\": \"\",\n  \"ServiceActionId\": \"\",\n  \"ExecuteToken\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"Parameters\": \"\"\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=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction";

    let payload = json!({
        "ProvisionedProductId": "",
        "ServiceActionId": "",
        "ExecuteToken": "",
        "AcceptLanguage": "",
        "Parameters": ""
    });

    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=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ProvisionedProductId": "",
  "ServiceActionId": "",
  "ExecuteToken": "",
  "AcceptLanguage": "",
  "Parameters": ""
}'

echo '{
  "ProvisionedProductId": "",
  "ServiceActionId": "",
  "ExecuteToken": "",
  "AcceptLanguage": "",
  "Parameters": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ProvisionedProductId": "",\n  "ServiceActionId": "",\n  "ExecuteToken": "",\n  "AcceptLanguage": "",\n  "Parameters": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ProvisionedProductId": "",
  "ServiceActionId": "",
  "ExecuteToken": "",
  "AcceptLanguage": "",
  "Parameters": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction")! 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 GetAWSOrganizationsAccessStatus

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus

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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus");

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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus" {:headers {:x-amz-target ""}
                                                                                                                      :content-type :json})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus"
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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus"),
    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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus");
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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus"

	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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus")
  .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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus"))
    .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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus")
  .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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus")
  .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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus');
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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus',
  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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus';
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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus',
  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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus")
  .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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus',
  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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus');

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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus',
  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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus';
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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus"]
                                                       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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus" 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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus",
  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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus');
$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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus');
$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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus' -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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus' -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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus"

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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus"

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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus")

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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus";

    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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{}'

echo '{}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus' \
  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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus'

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=AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus")! 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 GetProvisionedProductOutputs

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.GetProvisionedProductOutputs

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "ProvisionedProductId": "",
  "ProvisionedProductName": "",
  "OutputKeys": "",
  "PageSize": "",
  "PageToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.GetProvisionedProductOutputs");

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  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"OutputKeys\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.GetProvisionedProductOutputs" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:AcceptLanguage ""
                                                                                                                                 :ProvisionedProductId ""
                                                                                                                                 :ProvisionedProductName ""
                                                                                                                                 :OutputKeys ""
                                                                                                                                 :PageSize ""
                                                                                                                                 :PageToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.GetProvisionedProductOutputs"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"OutputKeys\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.GetProvisionedProductOutputs"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"OutputKeys\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.GetProvisionedProductOutputs");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"OutputKeys\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.GetProvisionedProductOutputs"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"OutputKeys\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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: 145

{
  "AcceptLanguage": "",
  "ProvisionedProductId": "",
  "ProvisionedProductName": "",
  "OutputKeys": "",
  "PageSize": "",
  "PageToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.GetProvisionedProductOutputs")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"OutputKeys\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.GetProvisionedProductOutputs"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"OutputKeys\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"OutputKeys\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.GetProvisionedProductOutputs")
  .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=AWS242ServiceCatalogService.GetProvisionedProductOutputs")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"OutputKeys\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  ProvisionedProductId: '',
  ProvisionedProductName: '',
  OutputKeys: '',
  PageSize: '',
  PageToken: ''
});

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=AWS242ServiceCatalogService.GetProvisionedProductOutputs');
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=AWS242ServiceCatalogService.GetProvisionedProductOutputs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    ProvisionedProductId: '',
    ProvisionedProductName: '',
    OutputKeys: '',
    PageSize: '',
    PageToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.GetProvisionedProductOutputs';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProvisionedProductId":"","ProvisionedProductName":"","OutputKeys":"","PageSize":"","PageToken":""}'
};

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=AWS242ServiceCatalogService.GetProvisionedProductOutputs',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "ProvisionedProductId": "",\n  "ProvisionedProductName": "",\n  "OutputKeys": "",\n  "PageSize": "",\n  "PageToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"OutputKeys\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.GetProvisionedProductOutputs")
  .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({
  AcceptLanguage: '',
  ProvisionedProductId: '',
  ProvisionedProductName: '',
  OutputKeys: '',
  PageSize: '',
  PageToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.GetProvisionedProductOutputs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AcceptLanguage: '',
    ProvisionedProductId: '',
    ProvisionedProductName: '',
    OutputKeys: '',
    PageSize: '',
    PageToken: ''
  },
  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=AWS242ServiceCatalogService.GetProvisionedProductOutputs');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  ProvisionedProductId: '',
  ProvisionedProductName: '',
  OutputKeys: '',
  PageSize: '',
  PageToken: ''
});

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=AWS242ServiceCatalogService.GetProvisionedProductOutputs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    ProvisionedProductId: '',
    ProvisionedProductName: '',
    OutputKeys: '',
    PageSize: '',
    PageToken: ''
  }
};

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=AWS242ServiceCatalogService.GetProvisionedProductOutputs';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProvisionedProductId":"","ProvisionedProductName":"","OutputKeys":"","PageSize":"","PageToken":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"ProvisionedProductId": @"",
                              @"ProvisionedProductName": @"",
                              @"OutputKeys": @"",
                              @"PageSize": @"",
                              @"PageToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.GetProvisionedProductOutputs"]
                                                       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=AWS242ServiceCatalogService.GetProvisionedProductOutputs" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"OutputKeys\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.GetProvisionedProductOutputs",
  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([
    'AcceptLanguage' => '',
    'ProvisionedProductId' => '',
    'ProvisionedProductName' => '',
    'OutputKeys' => '',
    'PageSize' => '',
    'PageToken' => ''
  ]),
  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=AWS242ServiceCatalogService.GetProvisionedProductOutputs', [
  'body' => '{
  "AcceptLanguage": "",
  "ProvisionedProductId": "",
  "ProvisionedProductName": "",
  "OutputKeys": "",
  "PageSize": "",
  "PageToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.GetProvisionedProductOutputs');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'ProvisionedProductId' => '',
  'ProvisionedProductName' => '',
  'OutputKeys' => '',
  'PageSize' => '',
  'PageToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'ProvisionedProductId' => '',
  'ProvisionedProductName' => '',
  'OutputKeys' => '',
  'PageSize' => '',
  'PageToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.GetProvisionedProductOutputs');
$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=AWS242ServiceCatalogService.GetProvisionedProductOutputs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ProvisionedProductId": "",
  "ProvisionedProductName": "",
  "OutputKeys": "",
  "PageSize": "",
  "PageToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.GetProvisionedProductOutputs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ProvisionedProductId": "",
  "ProvisionedProductName": "",
  "OutputKeys": "",
  "PageSize": "",
  "PageToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"OutputKeys\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.GetProvisionedProductOutputs"

payload = {
    "AcceptLanguage": "",
    "ProvisionedProductId": "",
    "ProvisionedProductName": "",
    "OutputKeys": "",
    "PageSize": "",
    "PageToken": ""
}
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=AWS242ServiceCatalogService.GetProvisionedProductOutputs"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"OutputKeys\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.GetProvisionedProductOutputs")

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  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"OutputKeys\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"OutputKeys\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.GetProvisionedProductOutputs";

    let payload = json!({
        "AcceptLanguage": "",
        "ProvisionedProductId": "",
        "ProvisionedProductName": "",
        "OutputKeys": "",
        "PageSize": "",
        "PageToken": ""
    });

    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=AWS242ServiceCatalogService.GetProvisionedProductOutputs' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "ProvisionedProductId": "",
  "ProvisionedProductName": "",
  "OutputKeys": "",
  "PageSize": "",
  "PageToken": ""
}'

echo '{
  "AcceptLanguage": "",
  "ProvisionedProductId": "",
  "ProvisionedProductName": "",
  "OutputKeys": "",
  "PageSize": "",
  "PageToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.GetProvisionedProductOutputs' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "ProvisionedProductId": "",\n  "ProvisionedProductName": "",\n  "OutputKeys": "",\n  "PageSize": "",\n  "PageToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.GetProvisionedProductOutputs'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "ProvisionedProductId": "",
  "ProvisionedProductName": "",
  "OutputKeys": "",
  "PageSize": "",
  "PageToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.GetProvisionedProductOutputs")! 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 ImportAsProvisionedProduct

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ImportAsProvisionedProduct

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "ProvisionedProductName": "",
  "PhysicalId": "",
  "IdempotencyToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ImportAsProvisionedProduct");

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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"PhysicalId\": \"\",\n  \"IdempotencyToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ImportAsProvisionedProduct" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:AcceptLanguage ""
                                                                                                                               :ProductId ""
                                                                                                                               :ProvisioningArtifactId ""
                                                                                                                               :ProvisionedProductName ""
                                                                                                                               :PhysicalId ""
                                                                                                                               :IdempotencyToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ImportAsProvisionedProduct"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"PhysicalId\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.ImportAsProvisionedProduct"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"PhysicalId\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.ImportAsProvisionedProduct");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"PhysicalId\": \"\",\n  \"IdempotencyToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ImportAsProvisionedProduct"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"PhysicalId\": \"\",\n  \"IdempotencyToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 155

{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "ProvisionedProductName": "",
  "PhysicalId": "",
  "IdempotencyToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ImportAsProvisionedProduct")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"PhysicalId\": \"\",\n  \"IdempotencyToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ImportAsProvisionedProduct"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"PhysicalId\": \"\",\n  \"IdempotencyToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"PhysicalId\": \"\",\n  \"IdempotencyToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ImportAsProvisionedProduct")
  .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=AWS242ServiceCatalogService.ImportAsProvisionedProduct")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"PhysicalId\": \"\",\n  \"IdempotencyToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  ProductId: '',
  ProvisioningArtifactId: '',
  ProvisionedProductName: '',
  PhysicalId: '',
  IdempotencyToken: ''
});

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=AWS242ServiceCatalogService.ImportAsProvisionedProduct');
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=AWS242ServiceCatalogService.ImportAsProvisionedProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    ProductId: '',
    ProvisioningArtifactId: '',
    ProvisionedProductName: '',
    PhysicalId: '',
    IdempotencyToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ImportAsProvisionedProduct';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProductId":"","ProvisioningArtifactId":"","ProvisionedProductName":"","PhysicalId":"","IdempotencyToken":""}'
};

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=AWS242ServiceCatalogService.ImportAsProvisionedProduct',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "ProductId": "",\n  "ProvisioningArtifactId": "",\n  "ProvisionedProductName": "",\n  "PhysicalId": "",\n  "IdempotencyToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"PhysicalId\": \"\",\n  \"IdempotencyToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ImportAsProvisionedProduct")
  .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({
  AcceptLanguage: '',
  ProductId: '',
  ProvisioningArtifactId: '',
  ProvisionedProductName: '',
  PhysicalId: '',
  IdempotencyToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ImportAsProvisionedProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AcceptLanguage: '',
    ProductId: '',
    ProvisioningArtifactId: '',
    ProvisionedProductName: '',
    PhysicalId: '',
    IdempotencyToken: ''
  },
  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=AWS242ServiceCatalogService.ImportAsProvisionedProduct');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  ProductId: '',
  ProvisioningArtifactId: '',
  ProvisionedProductName: '',
  PhysicalId: '',
  IdempotencyToken: ''
});

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=AWS242ServiceCatalogService.ImportAsProvisionedProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    ProductId: '',
    ProvisioningArtifactId: '',
    ProvisionedProductName: '',
    PhysicalId: '',
    IdempotencyToken: ''
  }
};

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=AWS242ServiceCatalogService.ImportAsProvisionedProduct';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProductId":"","ProvisioningArtifactId":"","ProvisionedProductName":"","PhysicalId":"","IdempotencyToken":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"ProductId": @"",
                              @"ProvisioningArtifactId": @"",
                              @"ProvisionedProductName": @"",
                              @"PhysicalId": @"",
                              @"IdempotencyToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ImportAsProvisionedProduct"]
                                                       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=AWS242ServiceCatalogService.ImportAsProvisionedProduct" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"PhysicalId\": \"\",\n  \"IdempotencyToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ImportAsProvisionedProduct",
  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([
    'AcceptLanguage' => '',
    'ProductId' => '',
    'ProvisioningArtifactId' => '',
    'ProvisionedProductName' => '',
    'PhysicalId' => '',
    'IdempotencyToken' => ''
  ]),
  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=AWS242ServiceCatalogService.ImportAsProvisionedProduct', [
  'body' => '{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "ProvisionedProductName": "",
  "PhysicalId": "",
  "IdempotencyToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ImportAsProvisionedProduct');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'ProductId' => '',
  'ProvisioningArtifactId' => '',
  'ProvisionedProductName' => '',
  'PhysicalId' => '',
  'IdempotencyToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'ProductId' => '',
  'ProvisioningArtifactId' => '',
  'ProvisionedProductName' => '',
  'PhysicalId' => '',
  'IdempotencyToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ImportAsProvisionedProduct');
$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=AWS242ServiceCatalogService.ImportAsProvisionedProduct' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "ProvisionedProductName": "",
  "PhysicalId": "",
  "IdempotencyToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ImportAsProvisionedProduct' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "ProvisionedProductName": "",
  "PhysicalId": "",
  "IdempotencyToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"PhysicalId\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.ImportAsProvisionedProduct"

payload = {
    "AcceptLanguage": "",
    "ProductId": "",
    "ProvisioningArtifactId": "",
    "ProvisionedProductName": "",
    "PhysicalId": "",
    "IdempotencyToken": ""
}
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=AWS242ServiceCatalogService.ImportAsProvisionedProduct"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"PhysicalId\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.ImportAsProvisionedProduct")

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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"PhysicalId\": \"\",\n  \"IdempotencyToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"PhysicalId\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.ImportAsProvisionedProduct";

    let payload = json!({
        "AcceptLanguage": "",
        "ProductId": "",
        "ProvisioningArtifactId": "",
        "ProvisionedProductName": "",
        "PhysicalId": "",
        "IdempotencyToken": ""
    });

    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=AWS242ServiceCatalogService.ImportAsProvisionedProduct' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "ProvisionedProductName": "",
  "PhysicalId": "",
  "IdempotencyToken": ""
}'

echo '{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "ProvisionedProductName": "",
  "PhysicalId": "",
  "IdempotencyToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ImportAsProvisionedProduct' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "ProductId": "",\n  "ProvisioningArtifactId": "",\n  "ProvisionedProductName": "",\n  "PhysicalId": "",\n  "IdempotencyToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ImportAsProvisionedProduct'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "ProvisionedProductName": "",
  "PhysicalId": "",
  "IdempotencyToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ImportAsProvisionedProduct")! 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 ListAcceptedPortfolioShares

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListAcceptedPortfolioShares

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "PageToken": "",
  "PageSize": "",
  "PortfolioShareType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListAcceptedPortfolioShares");

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  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"PortfolioShareType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListAcceptedPortfolioShares" {:headers {:x-amz-target ""}
                                                                                                                  :content-type :json
                                                                                                                  :form-params {:AcceptLanguage ""
                                                                                                                                :PageToken ""
                                                                                                                                :PageSize ""
                                                                                                                                :PortfolioShareType ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListAcceptedPortfolioShares"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"PortfolioShareType\": \"\"\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=AWS242ServiceCatalogService.ListAcceptedPortfolioShares"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"PortfolioShareType\": \"\"\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=AWS242ServiceCatalogService.ListAcceptedPortfolioShares");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"PortfolioShareType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListAcceptedPortfolioShares"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"PortfolioShareType\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 91

{
  "AcceptLanguage": "",
  "PageToken": "",
  "PageSize": "",
  "PortfolioShareType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListAcceptedPortfolioShares")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"PortfolioShareType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListAcceptedPortfolioShares"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"PortfolioShareType\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"PortfolioShareType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListAcceptedPortfolioShares")
  .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=AWS242ServiceCatalogService.ListAcceptedPortfolioShares")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"PortfolioShareType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  PageToken: '',
  PageSize: '',
  PortfolioShareType: ''
});

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=AWS242ServiceCatalogService.ListAcceptedPortfolioShares');
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=AWS242ServiceCatalogService.ListAcceptedPortfolioShares',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', PageToken: '', PageSize: '', PortfolioShareType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListAcceptedPortfolioShares';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PageToken":"","PageSize":"","PortfolioShareType":""}'
};

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=AWS242ServiceCatalogService.ListAcceptedPortfolioShares',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "PageToken": "",\n  "PageSize": "",\n  "PortfolioShareType": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"PortfolioShareType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListAcceptedPortfolioShares")
  .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({AcceptLanguage: '', PageToken: '', PageSize: '', PortfolioShareType: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListAcceptedPortfolioShares',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AcceptLanguage: '', PageToken: '', PageSize: '', PortfolioShareType: ''},
  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=AWS242ServiceCatalogService.ListAcceptedPortfolioShares');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  PageToken: '',
  PageSize: '',
  PortfolioShareType: ''
});

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=AWS242ServiceCatalogService.ListAcceptedPortfolioShares',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', PageToken: '', PageSize: '', PortfolioShareType: ''}
};

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=AWS242ServiceCatalogService.ListAcceptedPortfolioShares';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PageToken":"","PageSize":"","PortfolioShareType":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"PageToken": @"",
                              @"PageSize": @"",
                              @"PortfolioShareType": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListAcceptedPortfolioShares"]
                                                       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=AWS242ServiceCatalogService.ListAcceptedPortfolioShares" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"PortfolioShareType\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListAcceptedPortfolioShares",
  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([
    'AcceptLanguage' => '',
    'PageToken' => '',
    'PageSize' => '',
    'PortfolioShareType' => ''
  ]),
  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=AWS242ServiceCatalogService.ListAcceptedPortfolioShares', [
  'body' => '{
  "AcceptLanguage": "",
  "PageToken": "",
  "PageSize": "",
  "PortfolioShareType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListAcceptedPortfolioShares');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'PageToken' => '',
  'PageSize' => '',
  'PortfolioShareType' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'PageToken' => '',
  'PageSize' => '',
  'PortfolioShareType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListAcceptedPortfolioShares');
$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=AWS242ServiceCatalogService.ListAcceptedPortfolioShares' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PageToken": "",
  "PageSize": "",
  "PortfolioShareType": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListAcceptedPortfolioShares' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PageToken": "",
  "PageSize": "",
  "PortfolioShareType": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"PortfolioShareType\": \"\"\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=AWS242ServiceCatalogService.ListAcceptedPortfolioShares"

payload = {
    "AcceptLanguage": "",
    "PageToken": "",
    "PageSize": "",
    "PortfolioShareType": ""
}
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=AWS242ServiceCatalogService.ListAcceptedPortfolioShares"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"PortfolioShareType\": \"\"\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=AWS242ServiceCatalogService.ListAcceptedPortfolioShares")

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  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"PortfolioShareType\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"PortfolioShareType\": \"\"\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=AWS242ServiceCatalogService.ListAcceptedPortfolioShares";

    let payload = json!({
        "AcceptLanguage": "",
        "PageToken": "",
        "PageSize": "",
        "PortfolioShareType": ""
    });

    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=AWS242ServiceCatalogService.ListAcceptedPortfolioShares' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "PageToken": "",
  "PageSize": "",
  "PortfolioShareType": ""
}'

echo '{
  "AcceptLanguage": "",
  "PageToken": "",
  "PageSize": "",
  "PortfolioShareType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListAcceptedPortfolioShares' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "PageToken": "",\n  "PageSize": "",\n  "PortfolioShareType": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListAcceptedPortfolioShares'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "PageToken": "",
  "PageSize": "",
  "PortfolioShareType": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListAcceptedPortfolioShares")! 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 ListBudgetsForResource

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListBudgetsForResource

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "ResourceId": "",
  "PageSize": "",
  "PageToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListBudgetsForResource");

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  \"AcceptLanguage\": \"\",\n  \"ResourceId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListBudgetsForResource" {:headers {:x-amz-target ""}
                                                                                                             :content-type :json
                                                                                                             :form-params {:AcceptLanguage ""
                                                                                                                           :ResourceId ""
                                                                                                                           :PageSize ""
                                                                                                                           :PageToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListBudgetsForResource"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"ResourceId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListBudgetsForResource"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"ResourceId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListBudgetsForResource");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"ResourceId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListBudgetsForResource"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"ResourceId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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: 83

{
  "AcceptLanguage": "",
  "ResourceId": "",
  "PageSize": "",
  "PageToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListBudgetsForResource")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"ResourceId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListBudgetsForResource"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"ResourceId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ResourceId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListBudgetsForResource")
  .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=AWS242ServiceCatalogService.ListBudgetsForResource")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"ResourceId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  ResourceId: '',
  PageSize: '',
  PageToken: ''
});

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=AWS242ServiceCatalogService.ListBudgetsForResource');
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=AWS242ServiceCatalogService.ListBudgetsForResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', ResourceId: '', PageSize: '', PageToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListBudgetsForResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ResourceId":"","PageSize":"","PageToken":""}'
};

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=AWS242ServiceCatalogService.ListBudgetsForResource',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "ResourceId": "",\n  "PageSize": "",\n  "PageToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"ResourceId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListBudgetsForResource")
  .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({AcceptLanguage: '', ResourceId: '', PageSize: '', PageToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListBudgetsForResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AcceptLanguage: '', ResourceId: '', PageSize: '', PageToken: ''},
  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=AWS242ServiceCatalogService.ListBudgetsForResource');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  ResourceId: '',
  PageSize: '',
  PageToken: ''
});

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=AWS242ServiceCatalogService.ListBudgetsForResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', ResourceId: '', PageSize: '', PageToken: ''}
};

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=AWS242ServiceCatalogService.ListBudgetsForResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ResourceId":"","PageSize":"","PageToken":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"ResourceId": @"",
                              @"PageSize": @"",
                              @"PageToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListBudgetsForResource"]
                                                       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=AWS242ServiceCatalogService.ListBudgetsForResource" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"ResourceId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListBudgetsForResource",
  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([
    'AcceptLanguage' => '',
    'ResourceId' => '',
    'PageSize' => '',
    'PageToken' => ''
  ]),
  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=AWS242ServiceCatalogService.ListBudgetsForResource', [
  'body' => '{
  "AcceptLanguage": "",
  "ResourceId": "",
  "PageSize": "",
  "PageToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListBudgetsForResource');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'ResourceId' => '',
  'PageSize' => '',
  'PageToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'ResourceId' => '',
  'PageSize' => '',
  'PageToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListBudgetsForResource');
$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=AWS242ServiceCatalogService.ListBudgetsForResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ResourceId": "",
  "PageSize": "",
  "PageToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListBudgetsForResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ResourceId": "",
  "PageSize": "",
  "PageToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"ResourceId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListBudgetsForResource"

payload = {
    "AcceptLanguage": "",
    "ResourceId": "",
    "PageSize": "",
    "PageToken": ""
}
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=AWS242ServiceCatalogService.ListBudgetsForResource"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"ResourceId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListBudgetsForResource")

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  \"AcceptLanguage\": \"\",\n  \"ResourceId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ResourceId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListBudgetsForResource";

    let payload = json!({
        "AcceptLanguage": "",
        "ResourceId": "",
        "PageSize": "",
        "PageToken": ""
    });

    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=AWS242ServiceCatalogService.ListBudgetsForResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "ResourceId": "",
  "PageSize": "",
  "PageToken": ""
}'

echo '{
  "AcceptLanguage": "",
  "ResourceId": "",
  "PageSize": "",
  "PageToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListBudgetsForResource' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "ResourceId": "",\n  "PageSize": "",\n  "PageToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListBudgetsForResource'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "ResourceId": "",
  "PageSize": "",
  "PageToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListBudgetsForResource")! 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 ListConstraintsForPortfolio

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListConstraintsForPortfolio

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "ProductId": "",
  "PageSize": "",
  "PageToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListConstraintsForPortfolio");

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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListConstraintsForPortfolio" {:headers {:x-amz-target ""}
                                                                                                                  :content-type :json
                                                                                                                  :form-params {:AcceptLanguage ""
                                                                                                                                :PortfolioId ""
                                                                                                                                :ProductId ""
                                                                                                                                :PageSize ""
                                                                                                                                :PageToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListConstraintsForPortfolio"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListConstraintsForPortfolio"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListConstraintsForPortfolio");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListConstraintsForPortfolio"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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: 103

{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "ProductId": "",
  "PageSize": "",
  "PageToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListConstraintsForPortfolio")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListConstraintsForPortfolio"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListConstraintsForPortfolio")
  .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=AWS242ServiceCatalogService.ListConstraintsForPortfolio")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  PortfolioId: '',
  ProductId: '',
  PageSize: '',
  PageToken: ''
});

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=AWS242ServiceCatalogService.ListConstraintsForPortfolio');
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=AWS242ServiceCatalogService.ListConstraintsForPortfolio',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    PortfolioId: '',
    ProductId: '',
    PageSize: '',
    PageToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListConstraintsForPortfolio';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PortfolioId":"","ProductId":"","PageSize":"","PageToken":""}'
};

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=AWS242ServiceCatalogService.ListConstraintsForPortfolio',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "PortfolioId": "",\n  "ProductId": "",\n  "PageSize": "",\n  "PageToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListConstraintsForPortfolio")
  .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({
  AcceptLanguage: '',
  PortfolioId: '',
  ProductId: '',
  PageSize: '',
  PageToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListConstraintsForPortfolio',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AcceptLanguage: '',
    PortfolioId: '',
    ProductId: '',
    PageSize: '',
    PageToken: ''
  },
  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=AWS242ServiceCatalogService.ListConstraintsForPortfolio');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  PortfolioId: '',
  ProductId: '',
  PageSize: '',
  PageToken: ''
});

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=AWS242ServiceCatalogService.ListConstraintsForPortfolio',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    PortfolioId: '',
    ProductId: '',
    PageSize: '',
    PageToken: ''
  }
};

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=AWS242ServiceCatalogService.ListConstraintsForPortfolio';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PortfolioId":"","ProductId":"","PageSize":"","PageToken":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"PortfolioId": @"",
                              @"ProductId": @"",
                              @"PageSize": @"",
                              @"PageToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListConstraintsForPortfolio"]
                                                       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=AWS242ServiceCatalogService.ListConstraintsForPortfolio" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListConstraintsForPortfolio",
  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([
    'AcceptLanguage' => '',
    'PortfolioId' => '',
    'ProductId' => '',
    'PageSize' => '',
    'PageToken' => ''
  ]),
  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=AWS242ServiceCatalogService.ListConstraintsForPortfolio', [
  'body' => '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "ProductId": "",
  "PageSize": "",
  "PageToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListConstraintsForPortfolio');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'PortfolioId' => '',
  'ProductId' => '',
  'PageSize' => '',
  'PageToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'PortfolioId' => '',
  'ProductId' => '',
  'PageSize' => '',
  'PageToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListConstraintsForPortfolio');
$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=AWS242ServiceCatalogService.ListConstraintsForPortfolio' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "ProductId": "",
  "PageSize": "",
  "PageToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListConstraintsForPortfolio' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "ProductId": "",
  "PageSize": "",
  "PageToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListConstraintsForPortfolio"

payload = {
    "AcceptLanguage": "",
    "PortfolioId": "",
    "ProductId": "",
    "PageSize": "",
    "PageToken": ""
}
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=AWS242ServiceCatalogService.ListConstraintsForPortfolio"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListConstraintsForPortfolio")

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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListConstraintsForPortfolio";

    let payload = json!({
        "AcceptLanguage": "",
        "PortfolioId": "",
        "ProductId": "",
        "PageSize": "",
        "PageToken": ""
    });

    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=AWS242ServiceCatalogService.ListConstraintsForPortfolio' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "ProductId": "",
  "PageSize": "",
  "PageToken": ""
}'

echo '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "ProductId": "",
  "PageSize": "",
  "PageToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListConstraintsForPortfolio' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "PortfolioId": "",\n  "ProductId": "",\n  "PageSize": "",\n  "PageToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListConstraintsForPortfolio'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "PortfolioId": "",
  "ProductId": "",
  "PageSize": "",
  "PageToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListConstraintsForPortfolio")! 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 ListLaunchPaths

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListLaunchPaths

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "ProductId": "",
  "PageSize": "",
  "PageToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListLaunchPaths");

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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListLaunchPaths" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:AcceptLanguage ""
                                                                                                                    :ProductId ""
                                                                                                                    :PageSize ""
                                                                                                                    :PageToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListLaunchPaths"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListLaunchPaths"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListLaunchPaths");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListLaunchPaths"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 82

{
  "AcceptLanguage": "",
  "ProductId": "",
  "PageSize": "",
  "PageToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListLaunchPaths")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListLaunchPaths"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListLaunchPaths")
  .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=AWS242ServiceCatalogService.ListLaunchPaths")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  ProductId: '',
  PageSize: '',
  PageToken: ''
});

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=AWS242ServiceCatalogService.ListLaunchPaths');
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=AWS242ServiceCatalogService.ListLaunchPaths',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', ProductId: '', PageSize: '', PageToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListLaunchPaths';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProductId":"","PageSize":"","PageToken":""}'
};

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=AWS242ServiceCatalogService.ListLaunchPaths',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "ProductId": "",\n  "PageSize": "",\n  "PageToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListLaunchPaths")
  .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({AcceptLanguage: '', ProductId: '', PageSize: '', PageToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListLaunchPaths',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AcceptLanguage: '', ProductId: '', PageSize: '', PageToken: ''},
  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=AWS242ServiceCatalogService.ListLaunchPaths');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  ProductId: '',
  PageSize: '',
  PageToken: ''
});

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=AWS242ServiceCatalogService.ListLaunchPaths',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', ProductId: '', PageSize: '', PageToken: ''}
};

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=AWS242ServiceCatalogService.ListLaunchPaths';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProductId":"","PageSize":"","PageToken":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"ProductId": @"",
                              @"PageSize": @"",
                              @"PageToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListLaunchPaths"]
                                                       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=AWS242ServiceCatalogService.ListLaunchPaths" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListLaunchPaths",
  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([
    'AcceptLanguage' => '',
    'ProductId' => '',
    'PageSize' => '',
    'PageToken' => ''
  ]),
  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=AWS242ServiceCatalogService.ListLaunchPaths', [
  'body' => '{
  "AcceptLanguage": "",
  "ProductId": "",
  "PageSize": "",
  "PageToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListLaunchPaths');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'ProductId' => '',
  'PageSize' => '',
  'PageToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'ProductId' => '',
  'PageSize' => '',
  'PageToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListLaunchPaths');
$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=AWS242ServiceCatalogService.ListLaunchPaths' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ProductId": "",
  "PageSize": "",
  "PageToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListLaunchPaths' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ProductId": "",
  "PageSize": "",
  "PageToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListLaunchPaths"

payload = {
    "AcceptLanguage": "",
    "ProductId": "",
    "PageSize": "",
    "PageToken": ""
}
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=AWS242ServiceCatalogService.ListLaunchPaths"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListLaunchPaths")

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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListLaunchPaths";

    let payload = json!({
        "AcceptLanguage": "",
        "ProductId": "",
        "PageSize": "",
        "PageToken": ""
    });

    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=AWS242ServiceCatalogService.ListLaunchPaths' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "ProductId": "",
  "PageSize": "",
  "PageToken": ""
}'

echo '{
  "AcceptLanguage": "",
  "ProductId": "",
  "PageSize": "",
  "PageToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListLaunchPaths' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "ProductId": "",\n  "PageSize": "",\n  "PageToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListLaunchPaths'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "ProductId": "",
  "PageSize": "",
  "PageToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListLaunchPaths")! 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 ListOrganizationPortfolioAccess

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "OrganizationNodeType": "",
  "PageToken": "",
  "PageSize": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess");

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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationNodeType\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess" {:headers {:x-amz-target ""}
                                                                                                                      :content-type :json
                                                                                                                      :form-params {:AcceptLanguage ""
                                                                                                                                    :PortfolioId ""
                                                                                                                                    :OrganizationNodeType ""
                                                                                                                                    :PageToken ""
                                                                                                                                    :PageSize ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationNodeType\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationNodeType\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationNodeType\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationNodeType\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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: 114

{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "OrganizationNodeType": "",
  "PageToken": "",
  "PageSize": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationNodeType\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationNodeType\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationNodeType\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess")
  .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=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationNodeType\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  PortfolioId: '',
  OrganizationNodeType: '',
  PageToken: '',
  PageSize: ''
});

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=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess');
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=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    PortfolioId: '',
    OrganizationNodeType: '',
    PageToken: '',
    PageSize: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PortfolioId":"","OrganizationNodeType":"","PageToken":"","PageSize":""}'
};

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=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "PortfolioId": "",\n  "OrganizationNodeType": "",\n  "PageToken": "",\n  "PageSize": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationNodeType\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess")
  .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({
  AcceptLanguage: '',
  PortfolioId: '',
  OrganizationNodeType: '',
  PageToken: '',
  PageSize: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AcceptLanguage: '',
    PortfolioId: '',
    OrganizationNodeType: '',
    PageToken: '',
    PageSize: ''
  },
  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=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  PortfolioId: '',
  OrganizationNodeType: '',
  PageToken: '',
  PageSize: ''
});

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=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    PortfolioId: '',
    OrganizationNodeType: '',
    PageToken: '',
    PageSize: ''
  }
};

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=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PortfolioId":"","OrganizationNodeType":"","PageToken":"","PageSize":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"PortfolioId": @"",
                              @"OrganizationNodeType": @"",
                              @"PageToken": @"",
                              @"PageSize": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess"]
                                                       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=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationNodeType\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess",
  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([
    'AcceptLanguage' => '',
    'PortfolioId' => '',
    'OrganizationNodeType' => '',
    'PageToken' => '',
    'PageSize' => ''
  ]),
  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=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess', [
  'body' => '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "OrganizationNodeType": "",
  "PageToken": "",
  "PageSize": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'PortfolioId' => '',
  'OrganizationNodeType' => '',
  'PageToken' => '',
  'PageSize' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'PortfolioId' => '',
  'OrganizationNodeType' => '',
  'PageToken' => '',
  'PageSize' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess');
$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=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "OrganizationNodeType": "",
  "PageToken": "",
  "PageSize": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "OrganizationNodeType": "",
  "PageToken": "",
  "PageSize": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationNodeType\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess"

payload = {
    "AcceptLanguage": "",
    "PortfolioId": "",
    "OrganizationNodeType": "",
    "PageToken": "",
    "PageSize": ""
}
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=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationNodeType\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess")

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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationNodeType\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationNodeType\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess";

    let payload = json!({
        "AcceptLanguage": "",
        "PortfolioId": "",
        "OrganizationNodeType": "",
        "PageToken": "",
        "PageSize": ""
    });

    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=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "OrganizationNodeType": "",
  "PageToken": "",
  "PageSize": ""
}'

echo '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "OrganizationNodeType": "",
  "PageToken": "",
  "PageSize": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "PortfolioId": "",\n  "OrganizationNodeType": "",\n  "PageToken": "",\n  "PageSize": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "PortfolioId": "",
  "OrganizationNodeType": "",
  "PageToken": "",
  "PageSize": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListOrganizationPortfolioAccess")! 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 ListPortfolioAccess

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolioAccess

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "OrganizationParentId": "",
  "PageToken": "",
  "PageSize": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolioAccess");

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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationParentId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolioAccess" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:AcceptLanguage ""
                                                                                                                        :PortfolioId ""
                                                                                                                        :OrganizationParentId ""
                                                                                                                        :PageToken ""
                                                                                                                        :PageSize ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolioAccess"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationParentId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.ListPortfolioAccess"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationParentId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.ListPortfolioAccess");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationParentId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolioAccess"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationParentId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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: 114

{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "OrganizationParentId": "",
  "PageToken": "",
  "PageSize": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolioAccess")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationParentId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolioAccess"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationParentId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationParentId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolioAccess")
  .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=AWS242ServiceCatalogService.ListPortfolioAccess")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationParentId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  PortfolioId: '',
  OrganizationParentId: '',
  PageToken: '',
  PageSize: ''
});

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=AWS242ServiceCatalogService.ListPortfolioAccess');
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=AWS242ServiceCatalogService.ListPortfolioAccess',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    PortfolioId: '',
    OrganizationParentId: '',
    PageToken: '',
    PageSize: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolioAccess';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PortfolioId":"","OrganizationParentId":"","PageToken":"","PageSize":""}'
};

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=AWS242ServiceCatalogService.ListPortfolioAccess',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "PortfolioId": "",\n  "OrganizationParentId": "",\n  "PageToken": "",\n  "PageSize": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationParentId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolioAccess")
  .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({
  AcceptLanguage: '',
  PortfolioId: '',
  OrganizationParentId: '',
  PageToken: '',
  PageSize: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolioAccess',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AcceptLanguage: '',
    PortfolioId: '',
    OrganizationParentId: '',
    PageToken: '',
    PageSize: ''
  },
  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=AWS242ServiceCatalogService.ListPortfolioAccess');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  PortfolioId: '',
  OrganizationParentId: '',
  PageToken: '',
  PageSize: ''
});

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=AWS242ServiceCatalogService.ListPortfolioAccess',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    PortfolioId: '',
    OrganizationParentId: '',
    PageToken: '',
    PageSize: ''
  }
};

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=AWS242ServiceCatalogService.ListPortfolioAccess';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PortfolioId":"","OrganizationParentId":"","PageToken":"","PageSize":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"PortfolioId": @"",
                              @"OrganizationParentId": @"",
                              @"PageToken": @"",
                              @"PageSize": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolioAccess"]
                                                       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=AWS242ServiceCatalogService.ListPortfolioAccess" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationParentId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolioAccess",
  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([
    'AcceptLanguage' => '',
    'PortfolioId' => '',
    'OrganizationParentId' => '',
    'PageToken' => '',
    'PageSize' => ''
  ]),
  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=AWS242ServiceCatalogService.ListPortfolioAccess', [
  'body' => '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "OrganizationParentId": "",
  "PageToken": "",
  "PageSize": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolioAccess');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'PortfolioId' => '',
  'OrganizationParentId' => '',
  'PageToken' => '',
  'PageSize' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'PortfolioId' => '',
  'OrganizationParentId' => '',
  'PageToken' => '',
  'PageSize' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolioAccess');
$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=AWS242ServiceCatalogService.ListPortfolioAccess' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "OrganizationParentId": "",
  "PageToken": "",
  "PageSize": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolioAccess' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "OrganizationParentId": "",
  "PageToken": "",
  "PageSize": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationParentId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.ListPortfolioAccess"

payload = {
    "AcceptLanguage": "",
    "PortfolioId": "",
    "OrganizationParentId": "",
    "PageToken": "",
    "PageSize": ""
}
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=AWS242ServiceCatalogService.ListPortfolioAccess"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationParentId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.ListPortfolioAccess")

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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationParentId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"OrganizationParentId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.ListPortfolioAccess";

    let payload = json!({
        "AcceptLanguage": "",
        "PortfolioId": "",
        "OrganizationParentId": "",
        "PageToken": "",
        "PageSize": ""
    });

    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=AWS242ServiceCatalogService.ListPortfolioAccess' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "OrganizationParentId": "",
  "PageToken": "",
  "PageSize": ""
}'

echo '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "OrganizationParentId": "",
  "PageToken": "",
  "PageSize": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolioAccess' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "PortfolioId": "",\n  "OrganizationParentId": "",\n  "PageToken": "",\n  "PageSize": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolioAccess'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "PortfolioId": "",
  "OrganizationParentId": "",
  "PageToken": "",
  "PageSize": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolioAccess")! 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 ListPortfolios

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolios

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "PageToken": "",
  "PageSize": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolios");

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  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolios" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:AcceptLanguage ""
                                                                                                                   :PageToken ""
                                                                                                                   :PageSize ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolios"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.ListPortfolios"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.ListPortfolios");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolios"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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: 63

{
  "AcceptLanguage": "",
  "PageToken": "",
  "PageSize": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolios")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolios"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolios")
  .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=AWS242ServiceCatalogService.ListPortfolios")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  PageToken: '',
  PageSize: ''
});

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=AWS242ServiceCatalogService.ListPortfolios');
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=AWS242ServiceCatalogService.ListPortfolios',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', PageToken: '', PageSize: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolios';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PageToken":"","PageSize":""}'
};

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=AWS242ServiceCatalogService.ListPortfolios',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "PageToken": "",\n  "PageSize": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolios")
  .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({AcceptLanguage: '', PageToken: '', PageSize: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolios',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AcceptLanguage: '', PageToken: '', PageSize: ''},
  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=AWS242ServiceCatalogService.ListPortfolios');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  PageToken: '',
  PageSize: ''
});

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=AWS242ServiceCatalogService.ListPortfolios',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', PageToken: '', PageSize: ''}
};

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=AWS242ServiceCatalogService.ListPortfolios';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PageToken":"","PageSize":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"PageToken": @"",
                              @"PageSize": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolios"]
                                                       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=AWS242ServiceCatalogService.ListPortfolios" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolios",
  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([
    'AcceptLanguage' => '',
    'PageToken' => '',
    'PageSize' => ''
  ]),
  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=AWS242ServiceCatalogService.ListPortfolios', [
  'body' => '{
  "AcceptLanguage": "",
  "PageToken": "",
  "PageSize": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolios');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'PageToken' => '',
  'PageSize' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'PageToken' => '',
  'PageSize' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolios');
$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=AWS242ServiceCatalogService.ListPortfolios' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PageToken": "",
  "PageSize": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolios' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PageToken": "",
  "PageSize": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.ListPortfolios"

payload = {
    "AcceptLanguage": "",
    "PageToken": "",
    "PageSize": ""
}
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=AWS242ServiceCatalogService.ListPortfolios"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.ListPortfolios")

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  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.ListPortfolios";

    let payload = json!({
        "AcceptLanguage": "",
        "PageToken": "",
        "PageSize": ""
    });

    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=AWS242ServiceCatalogService.ListPortfolios' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "PageToken": "",
  "PageSize": ""
}'

echo '{
  "AcceptLanguage": "",
  "PageToken": "",
  "PageSize": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolios' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "PageToken": "",\n  "PageSize": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolios'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "PageToken": "",
  "PageSize": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfolios")! 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 ListPortfoliosForProduct

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfoliosForProduct

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "ProductId": "",
  "PageToken": "",
  "PageSize": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfoliosForProduct");

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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfoliosForProduct" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:AcceptLanguage ""
                                                                                                                             :ProductId ""
                                                                                                                             :PageToken ""
                                                                                                                             :PageSize ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfoliosForProduct"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.ListPortfoliosForProduct"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.ListPortfoliosForProduct");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfoliosForProduct"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 82

{
  "AcceptLanguage": "",
  "ProductId": "",
  "PageToken": "",
  "PageSize": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfoliosForProduct")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfoliosForProduct"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfoliosForProduct")
  .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=AWS242ServiceCatalogService.ListPortfoliosForProduct")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  ProductId: '',
  PageToken: '',
  PageSize: ''
});

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=AWS242ServiceCatalogService.ListPortfoliosForProduct');
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=AWS242ServiceCatalogService.ListPortfoliosForProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', ProductId: '', PageToken: '', PageSize: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfoliosForProduct';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProductId":"","PageToken":"","PageSize":""}'
};

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=AWS242ServiceCatalogService.ListPortfoliosForProduct',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "ProductId": "",\n  "PageToken": "",\n  "PageSize": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfoliosForProduct")
  .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({AcceptLanguage: '', ProductId: '', PageToken: '', PageSize: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfoliosForProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AcceptLanguage: '', ProductId: '', PageToken: '', PageSize: ''},
  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=AWS242ServiceCatalogService.ListPortfoliosForProduct');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  ProductId: '',
  PageToken: '',
  PageSize: ''
});

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=AWS242ServiceCatalogService.ListPortfoliosForProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', ProductId: '', PageToken: '', PageSize: ''}
};

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=AWS242ServiceCatalogService.ListPortfoliosForProduct';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProductId":"","PageToken":"","PageSize":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"ProductId": @"",
                              @"PageToken": @"",
                              @"PageSize": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfoliosForProduct"]
                                                       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=AWS242ServiceCatalogService.ListPortfoliosForProduct" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfoliosForProduct",
  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([
    'AcceptLanguage' => '',
    'ProductId' => '',
    'PageToken' => '',
    'PageSize' => ''
  ]),
  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=AWS242ServiceCatalogService.ListPortfoliosForProduct', [
  'body' => '{
  "AcceptLanguage": "",
  "ProductId": "",
  "PageToken": "",
  "PageSize": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfoliosForProduct');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'ProductId' => '',
  'PageToken' => '',
  'PageSize' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'ProductId' => '',
  'PageToken' => '',
  'PageSize' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfoliosForProduct');
$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=AWS242ServiceCatalogService.ListPortfoliosForProduct' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ProductId": "",
  "PageToken": "",
  "PageSize": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfoliosForProduct' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ProductId": "",
  "PageToken": "",
  "PageSize": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.ListPortfoliosForProduct"

payload = {
    "AcceptLanguage": "",
    "ProductId": "",
    "PageToken": "",
    "PageSize": ""
}
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=AWS242ServiceCatalogService.ListPortfoliosForProduct"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.ListPortfoliosForProduct")

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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.ListPortfoliosForProduct";

    let payload = json!({
        "AcceptLanguage": "",
        "ProductId": "",
        "PageToken": "",
        "PageSize": ""
    });

    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=AWS242ServiceCatalogService.ListPortfoliosForProduct' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "ProductId": "",
  "PageToken": "",
  "PageSize": ""
}'

echo '{
  "AcceptLanguage": "",
  "ProductId": "",
  "PageToken": "",
  "PageSize": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfoliosForProduct' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "ProductId": "",\n  "PageToken": "",\n  "PageSize": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfoliosForProduct'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "ProductId": "",
  "PageToken": "",
  "PageSize": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPortfoliosForProduct")! 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 ListPrincipalsForPortfolio

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPrincipalsForPortfolio

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PageSize": "",
  "PageToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPrincipalsForPortfolio");

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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPrincipalsForPortfolio" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:AcceptLanguage ""
                                                                                                                               :PortfolioId ""
                                                                                                                               :PageSize ""
                                                                                                                               :PageToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPrincipalsForPortfolio"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListPrincipalsForPortfolio"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListPrincipalsForPortfolio");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPrincipalsForPortfolio"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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

{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PageSize": "",
  "PageToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPrincipalsForPortfolio")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPrincipalsForPortfolio"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPrincipalsForPortfolio")
  .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=AWS242ServiceCatalogService.ListPrincipalsForPortfolio")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  PortfolioId: '',
  PageSize: '',
  PageToken: ''
});

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=AWS242ServiceCatalogService.ListPrincipalsForPortfolio');
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=AWS242ServiceCatalogService.ListPrincipalsForPortfolio',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', PortfolioId: '', PageSize: '', PageToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPrincipalsForPortfolio';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PortfolioId":"","PageSize":"","PageToken":""}'
};

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=AWS242ServiceCatalogService.ListPrincipalsForPortfolio',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "PortfolioId": "",\n  "PageSize": "",\n  "PageToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPrincipalsForPortfolio")
  .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({AcceptLanguage: '', PortfolioId: '', PageSize: '', PageToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPrincipalsForPortfolio',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AcceptLanguage: '', PortfolioId: '', PageSize: '', PageToken: ''},
  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=AWS242ServiceCatalogService.ListPrincipalsForPortfolio');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  PortfolioId: '',
  PageSize: '',
  PageToken: ''
});

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=AWS242ServiceCatalogService.ListPrincipalsForPortfolio',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', PortfolioId: '', PageSize: '', PageToken: ''}
};

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=AWS242ServiceCatalogService.ListPrincipalsForPortfolio';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PortfolioId":"","PageSize":"","PageToken":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"PortfolioId": @"",
                              @"PageSize": @"",
                              @"PageToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPrincipalsForPortfolio"]
                                                       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=AWS242ServiceCatalogService.ListPrincipalsForPortfolio" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPrincipalsForPortfolio",
  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([
    'AcceptLanguage' => '',
    'PortfolioId' => '',
    'PageSize' => '',
    'PageToken' => ''
  ]),
  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=AWS242ServiceCatalogService.ListPrincipalsForPortfolio', [
  'body' => '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PageSize": "",
  "PageToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPrincipalsForPortfolio');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'PortfolioId' => '',
  'PageSize' => '',
  'PageToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'PortfolioId' => '',
  'PageSize' => '',
  'PageToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPrincipalsForPortfolio');
$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=AWS242ServiceCatalogService.ListPrincipalsForPortfolio' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PageSize": "",
  "PageToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPrincipalsForPortfolio' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PageSize": "",
  "PageToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListPrincipalsForPortfolio"

payload = {
    "AcceptLanguage": "",
    "PortfolioId": "",
    "PageSize": "",
    "PageToken": ""
}
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=AWS242ServiceCatalogService.ListPrincipalsForPortfolio"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListPrincipalsForPortfolio")

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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListPrincipalsForPortfolio";

    let payload = json!({
        "AcceptLanguage": "",
        "PortfolioId": "",
        "PageSize": "",
        "PageToken": ""
    });

    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=AWS242ServiceCatalogService.ListPrincipalsForPortfolio' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PageSize": "",
  "PageToken": ""
}'

echo '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PageSize": "",
  "PageToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPrincipalsForPortfolio' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "PortfolioId": "",\n  "PageSize": "",\n  "PageToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPrincipalsForPortfolio'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PageSize": "",
  "PageToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListPrincipalsForPortfolio")! 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 ListProvisionedProductPlans

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisionedProductPlans

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "ProvisionProductId": "",
  "PageSize": "",
  "PageToken": "",
  "AccessLevelFilter": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisionedProductPlans");

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  \"AcceptLanguage\": \"\",\n  \"ProvisionProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AccessLevelFilter\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisionedProductPlans" {:headers {:x-amz-target ""}
                                                                                                                  :content-type :json
                                                                                                                  :form-params {:AcceptLanguage ""
                                                                                                                                :ProvisionProductId ""
                                                                                                                                :PageSize ""
                                                                                                                                :PageToken ""
                                                                                                                                :AccessLevelFilter ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisionedProductPlans"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AccessLevelFilter\": \"\"\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=AWS242ServiceCatalogService.ListProvisionedProductPlans"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AccessLevelFilter\": \"\"\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=AWS242ServiceCatalogService.ListProvisionedProductPlans");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AccessLevelFilter\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisionedProductPlans"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AccessLevelFilter\": \"\"\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

{
  "AcceptLanguage": "",
  "ProvisionProductId": "",
  "PageSize": "",
  "PageToken": "",
  "AccessLevelFilter": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisionedProductPlans")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AccessLevelFilter\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisionedProductPlans"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AccessLevelFilter\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProvisionProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AccessLevelFilter\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisionedProductPlans")
  .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=AWS242ServiceCatalogService.ListProvisionedProductPlans")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AccessLevelFilter\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  ProvisionProductId: '',
  PageSize: '',
  PageToken: '',
  AccessLevelFilter: ''
});

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=AWS242ServiceCatalogService.ListProvisionedProductPlans');
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=AWS242ServiceCatalogService.ListProvisionedProductPlans',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    ProvisionProductId: '',
    PageSize: '',
    PageToken: '',
    AccessLevelFilter: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisionedProductPlans';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProvisionProductId":"","PageSize":"","PageToken":"","AccessLevelFilter":""}'
};

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=AWS242ServiceCatalogService.ListProvisionedProductPlans',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "ProvisionProductId": "",\n  "PageSize": "",\n  "PageToken": "",\n  "AccessLevelFilter": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AccessLevelFilter\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisionedProductPlans")
  .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({
  AcceptLanguage: '',
  ProvisionProductId: '',
  PageSize: '',
  PageToken: '',
  AccessLevelFilter: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisionedProductPlans',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AcceptLanguage: '',
    ProvisionProductId: '',
    PageSize: '',
    PageToken: '',
    AccessLevelFilter: ''
  },
  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=AWS242ServiceCatalogService.ListProvisionedProductPlans');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  ProvisionProductId: '',
  PageSize: '',
  PageToken: '',
  AccessLevelFilter: ''
});

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=AWS242ServiceCatalogService.ListProvisionedProductPlans',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    ProvisionProductId: '',
    PageSize: '',
    PageToken: '',
    AccessLevelFilter: ''
  }
};

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=AWS242ServiceCatalogService.ListProvisionedProductPlans';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProvisionProductId":"","PageSize":"","PageToken":"","AccessLevelFilter":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"ProvisionProductId": @"",
                              @"PageSize": @"",
                              @"PageToken": @"",
                              @"AccessLevelFilter": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisionedProductPlans"]
                                                       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=AWS242ServiceCatalogService.ListProvisionedProductPlans" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AccessLevelFilter\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisionedProductPlans",
  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([
    'AcceptLanguage' => '',
    'ProvisionProductId' => '',
    'PageSize' => '',
    'PageToken' => '',
    'AccessLevelFilter' => ''
  ]),
  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=AWS242ServiceCatalogService.ListProvisionedProductPlans', [
  'body' => '{
  "AcceptLanguage": "",
  "ProvisionProductId": "",
  "PageSize": "",
  "PageToken": "",
  "AccessLevelFilter": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisionedProductPlans');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'ProvisionProductId' => '',
  'PageSize' => '',
  'PageToken' => '',
  'AccessLevelFilter' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'ProvisionProductId' => '',
  'PageSize' => '',
  'PageToken' => '',
  'AccessLevelFilter' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisionedProductPlans');
$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=AWS242ServiceCatalogService.ListProvisionedProductPlans' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ProvisionProductId": "",
  "PageSize": "",
  "PageToken": "",
  "AccessLevelFilter": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisionedProductPlans' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ProvisionProductId": "",
  "PageSize": "",
  "PageToken": "",
  "AccessLevelFilter": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AccessLevelFilter\": \"\"\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=AWS242ServiceCatalogService.ListProvisionedProductPlans"

payload = {
    "AcceptLanguage": "",
    "ProvisionProductId": "",
    "PageSize": "",
    "PageToken": "",
    "AccessLevelFilter": ""
}
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=AWS242ServiceCatalogService.ListProvisionedProductPlans"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AccessLevelFilter\": \"\"\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=AWS242ServiceCatalogService.ListProvisionedProductPlans")

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  \"AcceptLanguage\": \"\",\n  \"ProvisionProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AccessLevelFilter\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProvisionProductId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AccessLevelFilter\": \"\"\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=AWS242ServiceCatalogService.ListProvisionedProductPlans";

    let payload = json!({
        "AcceptLanguage": "",
        "ProvisionProductId": "",
        "PageSize": "",
        "PageToken": "",
        "AccessLevelFilter": ""
    });

    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=AWS242ServiceCatalogService.ListProvisionedProductPlans' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "ProvisionProductId": "",
  "PageSize": "",
  "PageToken": "",
  "AccessLevelFilter": ""
}'

echo '{
  "AcceptLanguage": "",
  "ProvisionProductId": "",
  "PageSize": "",
  "PageToken": "",
  "AccessLevelFilter": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisionedProductPlans' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "ProvisionProductId": "",\n  "PageSize": "",\n  "PageToken": "",\n  "AccessLevelFilter": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisionedProductPlans'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "ProvisionProductId": "",
  "PageSize": "",
  "PageToken": "",
  "AccessLevelFilter": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisionedProductPlans")! 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 ListProvisioningArtifacts

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifacts

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "ProductId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifacts");

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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifacts" {:headers {:x-amz-target ""}
                                                                                                                :content-type :json
                                                                                                                :form-params {:AcceptLanguage ""
                                                                                                                              :ProductId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifacts"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\"\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=AWS242ServiceCatalogService.ListProvisioningArtifacts"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\"\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=AWS242ServiceCatalogService.ListProvisioningArtifacts");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifacts"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\"\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

{
  "AcceptLanguage": "",
  "ProductId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifacts")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifacts"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifacts")
  .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=AWS242ServiceCatalogService.ListProvisioningArtifacts")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  ProductId: ''
});

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=AWS242ServiceCatalogService.ListProvisioningArtifacts');
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=AWS242ServiceCatalogService.ListProvisioningArtifacts',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', ProductId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifacts';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProductId":""}'
};

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=AWS242ServiceCatalogService.ListProvisioningArtifacts',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "ProductId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifacts")
  .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({AcceptLanguage: '', ProductId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifacts',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AcceptLanguage: '', ProductId: ''},
  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=AWS242ServiceCatalogService.ListProvisioningArtifacts');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  ProductId: ''
});

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=AWS242ServiceCatalogService.ListProvisioningArtifacts',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', ProductId: ''}
};

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=AWS242ServiceCatalogService.ListProvisioningArtifacts';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProductId":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"ProductId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifacts"]
                                                       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=AWS242ServiceCatalogService.ListProvisioningArtifacts" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifacts",
  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([
    'AcceptLanguage' => '',
    'ProductId' => ''
  ]),
  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=AWS242ServiceCatalogService.ListProvisioningArtifacts', [
  'body' => '{
  "AcceptLanguage": "",
  "ProductId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifacts');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'ProductId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'ProductId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifacts');
$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=AWS242ServiceCatalogService.ListProvisioningArtifacts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ProductId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifacts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ProductId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\"\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=AWS242ServiceCatalogService.ListProvisioningArtifacts"

payload = {
    "AcceptLanguage": "",
    "ProductId": ""
}
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=AWS242ServiceCatalogService.ListProvisioningArtifacts"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\"\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=AWS242ServiceCatalogService.ListProvisioningArtifacts")

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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\"\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=AWS242ServiceCatalogService.ListProvisioningArtifacts";

    let payload = json!({
        "AcceptLanguage": "",
        "ProductId": ""
    });

    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=AWS242ServiceCatalogService.ListProvisioningArtifacts' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "ProductId": ""
}'

echo '{
  "AcceptLanguage": "",
  "ProductId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifacts' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "ProductId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifacts'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "ProductId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifacts")! 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 ListProvisioningArtifactsForServiceAction

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction

HEADERS

X-Amz-Target

BODY json

{
  "ServiceActionId": "",
  "PageSize": "",
  "PageToken": "",
  "AcceptLanguage": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction");

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  \"ServiceActionId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction" {:headers {:x-amz-target ""}
                                                                                                                                :content-type :json
                                                                                                                                :form-params {:ServiceActionId ""
                                                                                                                                              :PageSize ""
                                                                                                                                              :PageToken ""
                                                                                                                                              :AcceptLanguage ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ServiceActionId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ServiceActionId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ServiceActionId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction"

	payload := strings.NewReader("{\n  \"ServiceActionId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 88

{
  "ServiceActionId": "",
  "PageSize": "",
  "PageToken": "",
  "AcceptLanguage": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ServiceActionId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ServiceActionId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\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  \"ServiceActionId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction")
  .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=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ServiceActionId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ServiceActionId: '',
  PageSize: '',
  PageToken: '',
  AcceptLanguage: ''
});

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=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction');
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=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ServiceActionId: '', PageSize: '', PageToken: '', AcceptLanguage: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ServiceActionId":"","PageSize":"","PageToken":"","AcceptLanguage":""}'
};

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=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ServiceActionId": "",\n  "PageSize": "",\n  "PageToken": "",\n  "AcceptLanguage": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ServiceActionId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction")
  .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({ServiceActionId: '', PageSize: '', PageToken: '', AcceptLanguage: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ServiceActionId: '', PageSize: '', PageToken: '', AcceptLanguage: ''},
  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=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ServiceActionId: '',
  PageSize: '',
  PageToken: '',
  AcceptLanguage: ''
});

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=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ServiceActionId: '', PageSize: '', PageToken: '', AcceptLanguage: ''}
};

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=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ServiceActionId":"","PageSize":"","PageToken":"","AcceptLanguage":""}'
};

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 = @{ @"ServiceActionId": @"",
                              @"PageSize": @"",
                              @"PageToken": @"",
                              @"AcceptLanguage": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction"]
                                                       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=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ServiceActionId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction",
  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([
    'ServiceActionId' => '',
    'PageSize' => '',
    'PageToken' => '',
    'AcceptLanguage' => ''
  ]),
  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=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction', [
  'body' => '{
  "ServiceActionId": "",
  "PageSize": "",
  "PageToken": "",
  "AcceptLanguage": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ServiceActionId' => '',
  'PageSize' => '',
  'PageToken' => '',
  'AcceptLanguage' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ServiceActionId' => '',
  'PageSize' => '',
  'PageToken' => '',
  'AcceptLanguage' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction');
$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=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ServiceActionId": "",
  "PageSize": "",
  "PageToken": "",
  "AcceptLanguage": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ServiceActionId": "",
  "PageSize": "",
  "PageToken": "",
  "AcceptLanguage": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ServiceActionId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction"

payload = {
    "ServiceActionId": "",
    "PageSize": "",
    "PageToken": "",
    "AcceptLanguage": ""
}
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=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction"

payload <- "{\n  \"ServiceActionId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction")

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  \"ServiceActionId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\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  \"ServiceActionId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction";

    let payload = json!({
        "ServiceActionId": "",
        "PageSize": "",
        "PageToken": "",
        "AcceptLanguage": ""
    });

    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=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ServiceActionId": "",
  "PageSize": "",
  "PageToken": "",
  "AcceptLanguage": ""
}'

echo '{
  "ServiceActionId": "",
  "PageSize": "",
  "PageToken": "",
  "AcceptLanguage": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ServiceActionId": "",\n  "PageSize": "",\n  "PageToken": "",\n  "AcceptLanguage": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ServiceActionId": "",
  "PageSize": "",
  "PageToken": "",
  "AcceptLanguage": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction")! 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 ListRecordHistory

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListRecordHistory

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "AccessLevelFilter": "",
  "SearchFilter": "",
  "PageSize": "",
  "PageToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListRecordHistory");

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  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"SearchFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListRecordHistory" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:AcceptLanguage ""
                                                                                                                      :AccessLevelFilter ""
                                                                                                                      :SearchFilter ""
                                                                                                                      :PageSize ""
                                                                                                                      :PageToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListRecordHistory"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"SearchFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListRecordHistory"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"SearchFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListRecordHistory");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"SearchFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListRecordHistory"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"SearchFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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: 112

{
  "AcceptLanguage": "",
  "AccessLevelFilter": "",
  "SearchFilter": "",
  "PageSize": "",
  "PageToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListRecordHistory")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"SearchFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListRecordHistory"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"SearchFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"SearchFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListRecordHistory")
  .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=AWS242ServiceCatalogService.ListRecordHistory")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"SearchFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  AccessLevelFilter: '',
  SearchFilter: '',
  PageSize: '',
  PageToken: ''
});

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=AWS242ServiceCatalogService.ListRecordHistory');
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=AWS242ServiceCatalogService.ListRecordHistory',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    AccessLevelFilter: '',
    SearchFilter: '',
    PageSize: '',
    PageToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListRecordHistory';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","AccessLevelFilter":"","SearchFilter":"","PageSize":"","PageToken":""}'
};

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=AWS242ServiceCatalogService.ListRecordHistory',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "AccessLevelFilter": "",\n  "SearchFilter": "",\n  "PageSize": "",\n  "PageToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"SearchFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListRecordHistory")
  .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({
  AcceptLanguage: '',
  AccessLevelFilter: '',
  SearchFilter: '',
  PageSize: '',
  PageToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListRecordHistory',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AcceptLanguage: '',
    AccessLevelFilter: '',
    SearchFilter: '',
    PageSize: '',
    PageToken: ''
  },
  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=AWS242ServiceCatalogService.ListRecordHistory');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  AccessLevelFilter: '',
  SearchFilter: '',
  PageSize: '',
  PageToken: ''
});

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=AWS242ServiceCatalogService.ListRecordHistory',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    AccessLevelFilter: '',
    SearchFilter: '',
    PageSize: '',
    PageToken: ''
  }
};

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=AWS242ServiceCatalogService.ListRecordHistory';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","AccessLevelFilter":"","SearchFilter":"","PageSize":"","PageToken":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"AccessLevelFilter": @"",
                              @"SearchFilter": @"",
                              @"PageSize": @"",
                              @"PageToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListRecordHistory"]
                                                       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=AWS242ServiceCatalogService.ListRecordHistory" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"SearchFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListRecordHistory",
  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([
    'AcceptLanguage' => '',
    'AccessLevelFilter' => '',
    'SearchFilter' => '',
    'PageSize' => '',
    'PageToken' => ''
  ]),
  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=AWS242ServiceCatalogService.ListRecordHistory', [
  'body' => '{
  "AcceptLanguage": "",
  "AccessLevelFilter": "",
  "SearchFilter": "",
  "PageSize": "",
  "PageToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListRecordHistory');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'AccessLevelFilter' => '',
  'SearchFilter' => '',
  'PageSize' => '',
  'PageToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'AccessLevelFilter' => '',
  'SearchFilter' => '',
  'PageSize' => '',
  'PageToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListRecordHistory');
$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=AWS242ServiceCatalogService.ListRecordHistory' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "AccessLevelFilter": "",
  "SearchFilter": "",
  "PageSize": "",
  "PageToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListRecordHistory' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "AccessLevelFilter": "",
  "SearchFilter": "",
  "PageSize": "",
  "PageToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"SearchFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListRecordHistory"

payload = {
    "AcceptLanguage": "",
    "AccessLevelFilter": "",
    "SearchFilter": "",
    "PageSize": "",
    "PageToken": ""
}
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=AWS242ServiceCatalogService.ListRecordHistory"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"SearchFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListRecordHistory")

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  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"SearchFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"SearchFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListRecordHistory";

    let payload = json!({
        "AcceptLanguage": "",
        "AccessLevelFilter": "",
        "SearchFilter": "",
        "PageSize": "",
        "PageToken": ""
    });

    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=AWS242ServiceCatalogService.ListRecordHistory' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "AccessLevelFilter": "",
  "SearchFilter": "",
  "PageSize": "",
  "PageToken": ""
}'

echo '{
  "AcceptLanguage": "",
  "AccessLevelFilter": "",
  "SearchFilter": "",
  "PageSize": "",
  "PageToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListRecordHistory' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "AccessLevelFilter": "",\n  "SearchFilter": "",\n  "PageSize": "",\n  "PageToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListRecordHistory'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "AccessLevelFilter": "",
  "SearchFilter": "",
  "PageSize": "",
  "PageToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListRecordHistory")! 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 ListResourcesForTagOption

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListResourcesForTagOption

HEADERS

X-Amz-Target

BODY json

{
  "TagOptionId": "",
  "ResourceType": "",
  "PageSize": "",
  "PageToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListResourcesForTagOption");

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  \"TagOptionId\": \"\",\n  \"ResourceType\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListResourcesForTagOption" {:headers {:x-amz-target ""}
                                                                                                                :content-type :json
                                                                                                                :form-params {:TagOptionId ""
                                                                                                                              :ResourceType ""
                                                                                                                              :PageSize ""
                                                                                                                              :PageToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListResourcesForTagOption"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TagOptionId\": \"\",\n  \"ResourceType\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListResourcesForTagOption"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TagOptionId\": \"\",\n  \"ResourceType\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListResourcesForTagOption");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TagOptionId\": \"\",\n  \"ResourceType\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListResourcesForTagOption"

	payload := strings.NewReader("{\n  \"TagOptionId\": \"\",\n  \"ResourceType\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 82

{
  "TagOptionId": "",
  "ResourceType": "",
  "PageSize": "",
  "PageToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListResourcesForTagOption")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TagOptionId\": \"\",\n  \"ResourceType\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListResourcesForTagOption"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TagOptionId\": \"\",\n  \"ResourceType\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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  \"TagOptionId\": \"\",\n  \"ResourceType\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListResourcesForTagOption")
  .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=AWS242ServiceCatalogService.ListResourcesForTagOption")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TagOptionId\": \"\",\n  \"ResourceType\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TagOptionId: '',
  ResourceType: '',
  PageSize: '',
  PageToken: ''
});

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=AWS242ServiceCatalogService.ListResourcesForTagOption');
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=AWS242ServiceCatalogService.ListResourcesForTagOption',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TagOptionId: '', ResourceType: '', PageSize: '', PageToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListResourcesForTagOption';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TagOptionId":"","ResourceType":"","PageSize":"","PageToken":""}'
};

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=AWS242ServiceCatalogService.ListResourcesForTagOption',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TagOptionId": "",\n  "ResourceType": "",\n  "PageSize": "",\n  "PageToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TagOptionId\": \"\",\n  \"ResourceType\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListResourcesForTagOption")
  .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({TagOptionId: '', ResourceType: '', PageSize: '', PageToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListResourcesForTagOption',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {TagOptionId: '', ResourceType: '', PageSize: '', PageToken: ''},
  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=AWS242ServiceCatalogService.ListResourcesForTagOption');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TagOptionId: '',
  ResourceType: '',
  PageSize: '',
  PageToken: ''
});

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=AWS242ServiceCatalogService.ListResourcesForTagOption',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TagOptionId: '', ResourceType: '', PageSize: '', PageToken: ''}
};

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=AWS242ServiceCatalogService.ListResourcesForTagOption';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TagOptionId":"","ResourceType":"","PageSize":"","PageToken":""}'
};

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 = @{ @"TagOptionId": @"",
                              @"ResourceType": @"",
                              @"PageSize": @"",
                              @"PageToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListResourcesForTagOption"]
                                                       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=AWS242ServiceCatalogService.ListResourcesForTagOption" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TagOptionId\": \"\",\n  \"ResourceType\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListResourcesForTagOption",
  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([
    'TagOptionId' => '',
    'ResourceType' => '',
    'PageSize' => '',
    'PageToken' => ''
  ]),
  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=AWS242ServiceCatalogService.ListResourcesForTagOption', [
  'body' => '{
  "TagOptionId": "",
  "ResourceType": "",
  "PageSize": "",
  "PageToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListResourcesForTagOption');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TagOptionId' => '',
  'ResourceType' => '',
  'PageSize' => '',
  'PageToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TagOptionId' => '',
  'ResourceType' => '',
  'PageSize' => '',
  'PageToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListResourcesForTagOption');
$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=AWS242ServiceCatalogService.ListResourcesForTagOption' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TagOptionId": "",
  "ResourceType": "",
  "PageSize": "",
  "PageToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListResourcesForTagOption' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TagOptionId": "",
  "ResourceType": "",
  "PageSize": "",
  "PageToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TagOptionId\": \"\",\n  \"ResourceType\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListResourcesForTagOption"

payload = {
    "TagOptionId": "",
    "ResourceType": "",
    "PageSize": "",
    "PageToken": ""
}
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=AWS242ServiceCatalogService.ListResourcesForTagOption"

payload <- "{\n  \"TagOptionId\": \"\",\n  \"ResourceType\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListResourcesForTagOption")

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  \"TagOptionId\": \"\",\n  \"ResourceType\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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  \"TagOptionId\": \"\",\n  \"ResourceType\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListResourcesForTagOption";

    let payload = json!({
        "TagOptionId": "",
        "ResourceType": "",
        "PageSize": "",
        "PageToken": ""
    });

    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=AWS242ServiceCatalogService.ListResourcesForTagOption' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "TagOptionId": "",
  "ResourceType": "",
  "PageSize": "",
  "PageToken": ""
}'

echo '{
  "TagOptionId": "",
  "ResourceType": "",
  "PageSize": "",
  "PageToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListResourcesForTagOption' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TagOptionId": "",\n  "ResourceType": "",\n  "PageSize": "",\n  "PageToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListResourcesForTagOption'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TagOptionId": "",
  "ResourceType": "",
  "PageSize": "",
  "PageToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListResourcesForTagOption")! 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 ListServiceActions

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActions

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "PageSize": "",
  "PageToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActions");

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  \"AcceptLanguage\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActions" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:AcceptLanguage ""
                                                                                                                       :PageSize ""
                                                                                                                       :PageToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActions"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListServiceActions"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListServiceActions");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActions"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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: 63

{
  "AcceptLanguage": "",
  "PageSize": "",
  "PageToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActions")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActions"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActions")
  .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=AWS242ServiceCatalogService.ListServiceActions")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  PageSize: '',
  PageToken: ''
});

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=AWS242ServiceCatalogService.ListServiceActions');
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=AWS242ServiceCatalogService.ListServiceActions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', PageSize: '', PageToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PageSize":"","PageToken":""}'
};

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=AWS242ServiceCatalogService.ListServiceActions',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "PageSize": "",\n  "PageToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActions")
  .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({AcceptLanguage: '', PageSize: '', PageToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AcceptLanguage: '', PageSize: '', PageToken: ''},
  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=AWS242ServiceCatalogService.ListServiceActions');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  PageSize: '',
  PageToken: ''
});

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=AWS242ServiceCatalogService.ListServiceActions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', PageSize: '', PageToken: ''}
};

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=AWS242ServiceCatalogService.ListServiceActions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PageSize":"","PageToken":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"PageSize": @"",
                              @"PageToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActions"]
                                                       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=AWS242ServiceCatalogService.ListServiceActions" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActions",
  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([
    'AcceptLanguage' => '',
    'PageSize' => '',
    'PageToken' => ''
  ]),
  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=AWS242ServiceCatalogService.ListServiceActions', [
  'body' => '{
  "AcceptLanguage": "",
  "PageSize": "",
  "PageToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'PageSize' => '',
  'PageToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'PageSize' => '',
  'PageToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActions');
$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=AWS242ServiceCatalogService.ListServiceActions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PageSize": "",
  "PageToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PageSize": "",
  "PageToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListServiceActions"

payload = {
    "AcceptLanguage": "",
    "PageSize": "",
    "PageToken": ""
}
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=AWS242ServiceCatalogService.ListServiceActions"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListServiceActions")

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  \"AcceptLanguage\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListServiceActions";

    let payload = json!({
        "AcceptLanguage": "",
        "PageSize": "",
        "PageToken": ""
    });

    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=AWS242ServiceCatalogService.ListServiceActions' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "PageSize": "",
  "PageToken": ""
}'

echo '{
  "AcceptLanguage": "",
  "PageSize": "",
  "PageToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActions' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "PageSize": "",\n  "PageToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActions'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "PageSize": "",
  "PageToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActions")! 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 ListServiceActionsForProvisioningArtifact

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact

HEADERS

X-Amz-Target

BODY json

{
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "PageSize": "",
  "PageToken": "",
  "AcceptLanguage": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact");

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  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact" {:headers {:x-amz-target ""}
                                                                                                                                :content-type :json
                                                                                                                                :form-params {:ProductId ""
                                                                                                                                              :ProvisioningArtifactId ""
                                                                                                                                              :PageSize ""
                                                                                                                                              :PageToken ""
                                                                                                                                              :AcceptLanguage ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact"

	payload := strings.NewReader("{\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\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: 114

{
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "PageSize": "",
  "PageToken": "",
  "AcceptLanguage": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\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  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact")
  .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=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ProductId: '',
  ProvisioningArtifactId: '',
  PageSize: '',
  PageToken: '',
  AcceptLanguage: ''
});

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=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact');
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=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ProductId: '',
    ProvisioningArtifactId: '',
    PageSize: '',
    PageToken: '',
    AcceptLanguage: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ProductId":"","ProvisioningArtifactId":"","PageSize":"","PageToken":"","AcceptLanguage":""}'
};

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=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ProductId": "",\n  "ProvisioningArtifactId": "",\n  "PageSize": "",\n  "PageToken": "",\n  "AcceptLanguage": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact")
  .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({
  ProductId: '',
  ProvisioningArtifactId: '',
  PageSize: '',
  PageToken: '',
  AcceptLanguage: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ProductId: '',
    ProvisioningArtifactId: '',
    PageSize: '',
    PageToken: '',
    AcceptLanguage: ''
  },
  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=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ProductId: '',
  ProvisioningArtifactId: '',
  PageSize: '',
  PageToken: '',
  AcceptLanguage: ''
});

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=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ProductId: '',
    ProvisioningArtifactId: '',
    PageSize: '',
    PageToken: '',
    AcceptLanguage: ''
  }
};

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=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ProductId":"","ProvisioningArtifactId":"","PageSize":"","PageToken":"","AcceptLanguage":""}'
};

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 = @{ @"ProductId": @"",
                              @"ProvisioningArtifactId": @"",
                              @"PageSize": @"",
                              @"PageToken": @"",
                              @"AcceptLanguage": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact"]
                                                       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=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact",
  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([
    'ProductId' => '',
    'ProvisioningArtifactId' => '',
    'PageSize' => '',
    'PageToken' => '',
    'AcceptLanguage' => ''
  ]),
  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=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact', [
  'body' => '{
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "PageSize": "",
  "PageToken": "",
  "AcceptLanguage": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ProductId' => '',
  'ProvisioningArtifactId' => '',
  'PageSize' => '',
  'PageToken' => '',
  'AcceptLanguage' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ProductId' => '',
  'ProvisioningArtifactId' => '',
  'PageSize' => '',
  'PageToken' => '',
  'AcceptLanguage' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact');
$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=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "PageSize": "",
  "PageToken": "",
  "AcceptLanguage": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "PageSize": "",
  "PageToken": "",
  "AcceptLanguage": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact"

payload = {
    "ProductId": "",
    "ProvisioningArtifactId": "",
    "PageSize": "",
    "PageToken": "",
    "AcceptLanguage": ""
}
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=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact"

payload <- "{\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact")

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  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\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  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact";

    let payload = json!({
        "ProductId": "",
        "ProvisioningArtifactId": "",
        "PageSize": "",
        "PageToken": "",
        "AcceptLanguage": ""
    });

    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=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "PageSize": "",
  "PageToken": "",
  "AcceptLanguage": ""
}'

echo '{
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "PageSize": "",
  "PageToken": "",
  "AcceptLanguage": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ProductId": "",\n  "ProvisioningArtifactId": "",\n  "PageSize": "",\n  "PageToken": "",\n  "AcceptLanguage": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "PageSize": "",
  "PageToken": "",
  "AcceptLanguage": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact")! 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 ListStackInstancesForProvisionedProduct

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "ProvisionedProductId": "",
  "PageToken": "",
  "PageSize": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct");

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  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct" {:headers {:x-amz-target ""}
                                                                                                                              :content-type :json
                                                                                                                              :form-params {:AcceptLanguage ""
                                                                                                                                            :ProvisionedProductId ""
                                                                                                                                            :PageToken ""
                                                                                                                                            :PageSize ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 93

{
  "AcceptLanguage": "",
  "ProvisionedProductId": "",
  "PageToken": "",
  "PageSize": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct")
  .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=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  ProvisionedProductId: '',
  PageToken: '',
  PageSize: ''
});

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=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct');
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=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', ProvisionedProductId: '', PageToken: '', PageSize: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProvisionedProductId":"","PageToken":"","PageSize":""}'
};

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=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "ProvisionedProductId": "",\n  "PageToken": "",\n  "PageSize": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct")
  .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({AcceptLanguage: '', ProvisionedProductId: '', PageToken: '', PageSize: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AcceptLanguage: '', ProvisionedProductId: '', PageToken: '', PageSize: ''},
  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=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  ProvisionedProductId: '',
  PageToken: '',
  PageSize: ''
});

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=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', ProvisionedProductId: '', PageToken: '', PageSize: ''}
};

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=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProvisionedProductId":"","PageToken":"","PageSize":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"ProvisionedProductId": @"",
                              @"PageToken": @"",
                              @"PageSize": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct"]
                                                       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=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct",
  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([
    'AcceptLanguage' => '',
    'ProvisionedProductId' => '',
    'PageToken' => '',
    'PageSize' => ''
  ]),
  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=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct', [
  'body' => '{
  "AcceptLanguage": "",
  "ProvisionedProductId": "",
  "PageToken": "",
  "PageSize": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'ProvisionedProductId' => '',
  'PageToken' => '',
  'PageSize' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'ProvisionedProductId' => '',
  'PageToken' => '',
  'PageSize' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct');
$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=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ProvisionedProductId": "",
  "PageToken": "",
  "PageSize": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ProvisionedProductId": "",
  "PageToken": "",
  "PageSize": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct"

payload = {
    "AcceptLanguage": "",
    "ProvisionedProductId": "",
    "PageToken": "",
    "PageSize": ""
}
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=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct")

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  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\"\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=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct";

    let payload = json!({
        "AcceptLanguage": "",
        "ProvisionedProductId": "",
        "PageToken": "",
        "PageSize": ""
    });

    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=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "ProvisionedProductId": "",
  "PageToken": "",
  "PageSize": ""
}'

echo '{
  "AcceptLanguage": "",
  "ProvisionedProductId": "",
  "PageToken": "",
  "PageSize": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "ProvisionedProductId": "",\n  "PageToken": "",\n  "PageSize": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "ProvisionedProductId": "",
  "PageToken": "",
  "PageSize": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct")! 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 ListTagOptions

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListTagOptions

HEADERS

X-Amz-Target

BODY json

{
  "Filters": "",
  "PageSize": "",
  "PageToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListTagOptions");

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  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListTagOptions" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:Filters ""
                                                                                                                   :PageSize ""
                                                                                                                   :PageToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListTagOptions"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListTagOptions"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListTagOptions");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListTagOptions"

	payload := strings.NewReader("{\n  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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

{
  "Filters": "",
  "PageSize": "",
  "PageToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListTagOptions")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListTagOptions"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListTagOptions")
  .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=AWS242ServiceCatalogService.ListTagOptions")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Filters: '',
  PageSize: '',
  PageToken: ''
});

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=AWS242ServiceCatalogService.ListTagOptions');
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=AWS242ServiceCatalogService.ListTagOptions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', PageSize: '', PageToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListTagOptions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","PageSize":"","PageToken":""}'
};

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=AWS242ServiceCatalogService.ListTagOptions',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Filters": "",\n  "PageSize": "",\n  "PageToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListTagOptions")
  .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({Filters: '', PageSize: '', PageToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListTagOptions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Filters: '', PageSize: '', PageToken: ''},
  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=AWS242ServiceCatalogService.ListTagOptions');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Filters: '',
  PageSize: '',
  PageToken: ''
});

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=AWS242ServiceCatalogService.ListTagOptions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', PageSize: '', PageToken: ''}
};

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=AWS242ServiceCatalogService.ListTagOptions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","PageSize":"","PageToken":""}'
};

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 = @{ @"Filters": @"",
                              @"PageSize": @"",
                              @"PageToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListTagOptions"]
                                                       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=AWS242ServiceCatalogService.ListTagOptions" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListTagOptions",
  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([
    'Filters' => '',
    'PageSize' => '',
    'PageToken' => ''
  ]),
  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=AWS242ServiceCatalogService.ListTagOptions', [
  'body' => '{
  "Filters": "",
  "PageSize": "",
  "PageToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListTagOptions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => '',
  'PageSize' => '',
  'PageToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Filters' => '',
  'PageSize' => '',
  'PageToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListTagOptions');
$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=AWS242ServiceCatalogService.ListTagOptions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "PageSize": "",
  "PageToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListTagOptions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "PageSize": "",
  "PageToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListTagOptions"

payload = {
    "Filters": "",
    "PageSize": "",
    "PageToken": ""
}
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=AWS242ServiceCatalogService.ListTagOptions"

payload <- "{\n  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListTagOptions")

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  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ListTagOptions";

    let payload = json!({
        "Filters": "",
        "PageSize": "",
        "PageToken": ""
    });

    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=AWS242ServiceCatalogService.ListTagOptions' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Filters": "",
  "PageSize": "",
  "PageToken": ""
}'

echo '{
  "Filters": "",
  "PageSize": "",
  "PageToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListTagOptions' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Filters": "",\n  "PageSize": "",\n  "PageToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListTagOptions'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Filters": "",
  "PageSize": "",
  "PageToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ListTagOptions")! 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 NotifyProvisionProductEngineWorkflowResult

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult

HEADERS

X-Amz-Target

BODY json

{
  "WorkflowToken": "",
  "RecordId": "",
  "Status": "",
  "FailureReason": "",
  "ResourceIdentifier": "",
  "Outputs": "",
  "IdempotencyToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult");

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  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult" {:headers {:x-amz-target ""}
                                                                                                                                 :content-type :json
                                                                                                                                 :form-params {:WorkflowToken ""
                                                                                                                                               :RecordId ""
                                                                                                                                               :Status ""
                                                                                                                                               :FailureReason ""
                                                                                                                                               :ResourceIdentifier ""
                                                                                                                                               :Outputs ""
                                                                                                                                               :IdempotencyToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult"

	payload := strings.NewReader("{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\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: 153

{
  "WorkflowToken": "",
  "RecordId": "",
  "Status": "",
  "FailureReason": "",
  "ResourceIdentifier": "",
  "Outputs": "",
  "IdempotencyToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\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  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult")
  .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=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  WorkflowToken: '',
  RecordId: '',
  Status: '',
  FailureReason: '',
  ResourceIdentifier: '',
  Outputs: '',
  IdempotencyToken: ''
});

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=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult');
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=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    WorkflowToken: '',
    RecordId: '',
    Status: '',
    FailureReason: '',
    ResourceIdentifier: '',
    Outputs: '',
    IdempotencyToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WorkflowToken":"","RecordId":"","Status":"","FailureReason":"","ResourceIdentifier":"","Outputs":"","IdempotencyToken":""}'
};

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=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "WorkflowToken": "",\n  "RecordId": "",\n  "Status": "",\n  "FailureReason": "",\n  "ResourceIdentifier": "",\n  "Outputs": "",\n  "IdempotencyToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult")
  .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({
  WorkflowToken: '',
  RecordId: '',
  Status: '',
  FailureReason: '',
  ResourceIdentifier: '',
  Outputs: '',
  IdempotencyToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    WorkflowToken: '',
    RecordId: '',
    Status: '',
    FailureReason: '',
    ResourceIdentifier: '',
    Outputs: '',
    IdempotencyToken: ''
  },
  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=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  WorkflowToken: '',
  RecordId: '',
  Status: '',
  FailureReason: '',
  ResourceIdentifier: '',
  Outputs: '',
  IdempotencyToken: ''
});

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=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    WorkflowToken: '',
    RecordId: '',
    Status: '',
    FailureReason: '',
    ResourceIdentifier: '',
    Outputs: '',
    IdempotencyToken: ''
  }
};

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=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WorkflowToken":"","RecordId":"","Status":"","FailureReason":"","ResourceIdentifier":"","Outputs":"","IdempotencyToken":""}'
};

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 = @{ @"WorkflowToken": @"",
                              @"RecordId": @"",
                              @"Status": @"",
                              @"FailureReason": @"",
                              @"ResourceIdentifier": @"",
                              @"Outputs": @"",
                              @"IdempotencyToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult"]
                                                       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=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult",
  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([
    'WorkflowToken' => '',
    'RecordId' => '',
    'Status' => '',
    'FailureReason' => '',
    'ResourceIdentifier' => '',
    'Outputs' => '',
    'IdempotencyToken' => ''
  ]),
  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=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult', [
  'body' => '{
  "WorkflowToken": "",
  "RecordId": "",
  "Status": "",
  "FailureReason": "",
  "ResourceIdentifier": "",
  "Outputs": "",
  "IdempotencyToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'WorkflowToken' => '',
  'RecordId' => '',
  'Status' => '',
  'FailureReason' => '',
  'ResourceIdentifier' => '',
  'Outputs' => '',
  'IdempotencyToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'WorkflowToken' => '',
  'RecordId' => '',
  'Status' => '',
  'FailureReason' => '',
  'ResourceIdentifier' => '',
  'Outputs' => '',
  'IdempotencyToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult');
$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=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WorkflowToken": "",
  "RecordId": "",
  "Status": "",
  "FailureReason": "",
  "ResourceIdentifier": "",
  "Outputs": "",
  "IdempotencyToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WorkflowToken": "",
  "RecordId": "",
  "Status": "",
  "FailureReason": "",
  "ResourceIdentifier": "",
  "Outputs": "",
  "IdempotencyToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult"

payload = {
    "WorkflowToken": "",
    "RecordId": "",
    "Status": "",
    "FailureReason": "",
    "ResourceIdentifier": "",
    "Outputs": "",
    "IdempotencyToken": ""
}
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=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult"

payload <- "{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult")

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  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\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  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult";

    let payload = json!({
        "WorkflowToken": "",
        "RecordId": "",
        "Status": "",
        "FailureReason": "",
        "ResourceIdentifier": "",
        "Outputs": "",
        "IdempotencyToken": ""
    });

    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=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "WorkflowToken": "",
  "RecordId": "",
  "Status": "",
  "FailureReason": "",
  "ResourceIdentifier": "",
  "Outputs": "",
  "IdempotencyToken": ""
}'

echo '{
  "WorkflowToken": "",
  "RecordId": "",
  "Status": "",
  "FailureReason": "",
  "ResourceIdentifier": "",
  "Outputs": "",
  "IdempotencyToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "WorkflowToken": "",\n  "RecordId": "",\n  "Status": "",\n  "FailureReason": "",\n  "ResourceIdentifier": "",\n  "Outputs": "",\n  "IdempotencyToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "WorkflowToken": "",
  "RecordId": "",
  "Status": "",
  "FailureReason": "",
  "ResourceIdentifier": "",
  "Outputs": "",
  "IdempotencyToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyProvisionProductEngineWorkflowResult")! 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 NotifyTerminateProvisionedProductEngineWorkflowResult

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult

HEADERS

X-Amz-Target

BODY json

{
  "WorkflowToken": "",
  "RecordId": "",
  "Status": "",
  "FailureReason": "",
  "IdempotencyToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult");

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  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"IdempotencyToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult" {:headers {:x-amz-target ""}
                                                                                                                                            :content-type :json
                                                                                                                                            :form-params {:WorkflowToken ""
                                                                                                                                                          :RecordId ""
                                                                                                                                                          :Status ""
                                                                                                                                                          :FailureReason ""
                                                                                                                                                          :IdempotencyToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"IdempotencyToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult"

	payload := strings.NewReader("{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"IdempotencyToken\": \"\"\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

{
  "WorkflowToken": "",
  "RecordId": "",
  "Status": "",
  "FailureReason": "",
  "IdempotencyToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"IdempotencyToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"IdempotencyToken\": \"\"\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  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"IdempotencyToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult")
  .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=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"IdempotencyToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  WorkflowToken: '',
  RecordId: '',
  Status: '',
  FailureReason: '',
  IdempotencyToken: ''
});

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=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult');
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=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    WorkflowToken: '',
    RecordId: '',
    Status: '',
    FailureReason: '',
    IdempotencyToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WorkflowToken":"","RecordId":"","Status":"","FailureReason":"","IdempotencyToken":""}'
};

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=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "WorkflowToken": "",\n  "RecordId": "",\n  "Status": "",\n  "FailureReason": "",\n  "IdempotencyToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"IdempotencyToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult")
  .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({
  WorkflowToken: '',
  RecordId: '',
  Status: '',
  FailureReason: '',
  IdempotencyToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    WorkflowToken: '',
    RecordId: '',
    Status: '',
    FailureReason: '',
    IdempotencyToken: ''
  },
  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=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  WorkflowToken: '',
  RecordId: '',
  Status: '',
  FailureReason: '',
  IdempotencyToken: ''
});

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=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    WorkflowToken: '',
    RecordId: '',
    Status: '',
    FailureReason: '',
    IdempotencyToken: ''
  }
};

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=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WorkflowToken":"","RecordId":"","Status":"","FailureReason":"","IdempotencyToken":""}'
};

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 = @{ @"WorkflowToken": @"",
                              @"RecordId": @"",
                              @"Status": @"",
                              @"FailureReason": @"",
                              @"IdempotencyToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult"]
                                                       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=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"IdempotencyToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult",
  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([
    'WorkflowToken' => '',
    'RecordId' => '',
    'Status' => '',
    'FailureReason' => '',
    'IdempotencyToken' => ''
  ]),
  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=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult', [
  'body' => '{
  "WorkflowToken": "",
  "RecordId": "",
  "Status": "",
  "FailureReason": "",
  "IdempotencyToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'WorkflowToken' => '',
  'RecordId' => '',
  'Status' => '',
  'FailureReason' => '',
  'IdempotencyToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'WorkflowToken' => '',
  'RecordId' => '',
  'Status' => '',
  'FailureReason' => '',
  'IdempotencyToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult');
$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=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WorkflowToken": "",
  "RecordId": "",
  "Status": "",
  "FailureReason": "",
  "IdempotencyToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WorkflowToken": "",
  "RecordId": "",
  "Status": "",
  "FailureReason": "",
  "IdempotencyToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult"

payload = {
    "WorkflowToken": "",
    "RecordId": "",
    "Status": "",
    "FailureReason": "",
    "IdempotencyToken": ""
}
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=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult"

payload <- "{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult")

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  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"IdempotencyToken\": \"\"\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  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult";

    let payload = json!({
        "WorkflowToken": "",
        "RecordId": "",
        "Status": "",
        "FailureReason": "",
        "IdempotencyToken": ""
    });

    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=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "WorkflowToken": "",
  "RecordId": "",
  "Status": "",
  "FailureReason": "",
  "IdempotencyToken": ""
}'

echo '{
  "WorkflowToken": "",
  "RecordId": "",
  "Status": "",
  "FailureReason": "",
  "IdempotencyToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "WorkflowToken": "",\n  "RecordId": "",\n  "Status": "",\n  "FailureReason": "",\n  "IdempotencyToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "WorkflowToken": "",
  "RecordId": "",
  "Status": "",
  "FailureReason": "",
  "IdempotencyToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyTerminateProvisionedProductEngineWorkflowResult")! 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 NotifyUpdateProvisionedProductEngineWorkflowResult

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult

HEADERS

X-Amz-Target

BODY json

{
  "WorkflowToken": "",
  "RecordId": "",
  "Status": "",
  "FailureReason": "",
  "Outputs": "",
  "IdempotencyToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult");

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  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult" {:headers {:x-amz-target ""}
                                                                                                                                         :content-type :json
                                                                                                                                         :form-params {:WorkflowToken ""
                                                                                                                                                       :RecordId ""
                                                                                                                                                       :Status ""
                                                                                                                                                       :FailureReason ""
                                                                                                                                                       :Outputs ""
                                                                                                                                                       :IdempotencyToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult"

	payload := strings.NewReader("{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 125

{
  "WorkflowToken": "",
  "RecordId": "",
  "Status": "",
  "FailureReason": "",
  "Outputs": "",
  "IdempotencyToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\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  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult")
  .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=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  WorkflowToken: '',
  RecordId: '',
  Status: '',
  FailureReason: '',
  Outputs: '',
  IdempotencyToken: ''
});

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=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult');
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=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    WorkflowToken: '',
    RecordId: '',
    Status: '',
    FailureReason: '',
    Outputs: '',
    IdempotencyToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WorkflowToken":"","RecordId":"","Status":"","FailureReason":"","Outputs":"","IdempotencyToken":""}'
};

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=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "WorkflowToken": "",\n  "RecordId": "",\n  "Status": "",\n  "FailureReason": "",\n  "Outputs": "",\n  "IdempotencyToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult")
  .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({
  WorkflowToken: '',
  RecordId: '',
  Status: '',
  FailureReason: '',
  Outputs: '',
  IdempotencyToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    WorkflowToken: '',
    RecordId: '',
    Status: '',
    FailureReason: '',
    Outputs: '',
    IdempotencyToken: ''
  },
  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=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  WorkflowToken: '',
  RecordId: '',
  Status: '',
  FailureReason: '',
  Outputs: '',
  IdempotencyToken: ''
});

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=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    WorkflowToken: '',
    RecordId: '',
    Status: '',
    FailureReason: '',
    Outputs: '',
    IdempotencyToken: ''
  }
};

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=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WorkflowToken":"","RecordId":"","Status":"","FailureReason":"","Outputs":"","IdempotencyToken":""}'
};

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 = @{ @"WorkflowToken": @"",
                              @"RecordId": @"",
                              @"Status": @"",
                              @"FailureReason": @"",
                              @"Outputs": @"",
                              @"IdempotencyToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult"]
                                                       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=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult",
  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([
    'WorkflowToken' => '',
    'RecordId' => '',
    'Status' => '',
    'FailureReason' => '',
    'Outputs' => '',
    'IdempotencyToken' => ''
  ]),
  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=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult', [
  'body' => '{
  "WorkflowToken": "",
  "RecordId": "",
  "Status": "",
  "FailureReason": "",
  "Outputs": "",
  "IdempotencyToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'WorkflowToken' => '',
  'RecordId' => '',
  'Status' => '',
  'FailureReason' => '',
  'Outputs' => '',
  'IdempotencyToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'WorkflowToken' => '',
  'RecordId' => '',
  'Status' => '',
  'FailureReason' => '',
  'Outputs' => '',
  'IdempotencyToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult');
$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=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WorkflowToken": "",
  "RecordId": "",
  "Status": "",
  "FailureReason": "",
  "Outputs": "",
  "IdempotencyToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WorkflowToken": "",
  "RecordId": "",
  "Status": "",
  "FailureReason": "",
  "Outputs": "",
  "IdempotencyToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult"

payload = {
    "WorkflowToken": "",
    "RecordId": "",
    "Status": "",
    "FailureReason": "",
    "Outputs": "",
    "IdempotencyToken": ""
}
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=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult"

payload <- "{\n  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult")

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  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\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  \"WorkflowToken\": \"\",\n  \"RecordId\": \"\",\n  \"Status\": \"\",\n  \"FailureReason\": \"\",\n  \"Outputs\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult";

    let payload = json!({
        "WorkflowToken": "",
        "RecordId": "",
        "Status": "",
        "FailureReason": "",
        "Outputs": "",
        "IdempotencyToken": ""
    });

    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=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "WorkflowToken": "",
  "RecordId": "",
  "Status": "",
  "FailureReason": "",
  "Outputs": "",
  "IdempotencyToken": ""
}'

echo '{
  "WorkflowToken": "",
  "RecordId": "",
  "Status": "",
  "FailureReason": "",
  "Outputs": "",
  "IdempotencyToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "WorkflowToken": "",\n  "RecordId": "",\n  "Status": "",\n  "FailureReason": "",\n  "Outputs": "",\n  "IdempotencyToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "WorkflowToken": "",
  "RecordId": "",
  "Status": "",
  "FailureReason": "",
  "Outputs": "",
  "IdempotencyToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.NotifyUpdateProvisionedProductEngineWorkflowResult")! 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 ProvisionProduct

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ProvisionProduct

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningArtifactName": "",
  "PathId": "",
  "PathName": "",
  "ProvisionedProductName": "",
  "ProvisioningParameters": "",
  "ProvisioningPreferences": "",
  "Tags": "",
  "NotificationArns": "",
  "ProvisionToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ProvisionProduct");

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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"NotificationArns\": \"\",\n  \"ProvisionToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ProvisionProduct" {:headers {:x-amz-target ""}
                                                                                                       :content-type :json
                                                                                                       :form-params {:AcceptLanguage ""
                                                                                                                     :ProductId ""
                                                                                                                     :ProductName ""
                                                                                                                     :ProvisioningArtifactId ""
                                                                                                                     :ProvisioningArtifactName ""
                                                                                                                     :PathId ""
                                                                                                                     :PathName ""
                                                                                                                     :ProvisionedProductName ""
                                                                                                                     :ProvisioningParameters ""
                                                                                                                     :ProvisioningPreferences ""
                                                                                                                     :Tags ""
                                                                                                                     :NotificationArns ""
                                                                                                                     :ProvisionToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ProvisionProduct"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"NotificationArns\": \"\",\n  \"ProvisionToken\": \"\"\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=AWS242ServiceCatalogService.ProvisionProduct"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"NotificationArns\": \"\",\n  \"ProvisionToken\": \"\"\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=AWS242ServiceCatalogService.ProvisionProduct");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"NotificationArns\": \"\",\n  \"ProvisionToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ProvisionProduct"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"NotificationArns\": \"\",\n  \"ProvisionToken\": \"\"\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

{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningArtifactName": "",
  "PathId": "",
  "PathName": "",
  "ProvisionedProductName": "",
  "ProvisioningParameters": "",
  "ProvisioningPreferences": "",
  "Tags": "",
  "NotificationArns": "",
  "ProvisionToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ProvisionProduct")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"NotificationArns\": \"\",\n  \"ProvisionToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ProvisionProduct"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"NotificationArns\": \"\",\n  \"ProvisionToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"NotificationArns\": \"\",\n  \"ProvisionToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ProvisionProduct")
  .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=AWS242ServiceCatalogService.ProvisionProduct")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"NotificationArns\": \"\",\n  \"ProvisionToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  ProductId: '',
  ProductName: '',
  ProvisioningArtifactId: '',
  ProvisioningArtifactName: '',
  PathId: '',
  PathName: '',
  ProvisionedProductName: '',
  ProvisioningParameters: '',
  ProvisioningPreferences: '',
  Tags: '',
  NotificationArns: '',
  ProvisionToken: ''
});

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=AWS242ServiceCatalogService.ProvisionProduct');
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=AWS242ServiceCatalogService.ProvisionProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    ProductId: '',
    ProductName: '',
    ProvisioningArtifactId: '',
    ProvisioningArtifactName: '',
    PathId: '',
    PathName: '',
    ProvisionedProductName: '',
    ProvisioningParameters: '',
    ProvisioningPreferences: '',
    Tags: '',
    NotificationArns: '',
    ProvisionToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ProvisionProduct';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProductId":"","ProductName":"","ProvisioningArtifactId":"","ProvisioningArtifactName":"","PathId":"","PathName":"","ProvisionedProductName":"","ProvisioningParameters":"","ProvisioningPreferences":"","Tags":"","NotificationArns":"","ProvisionToken":""}'
};

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=AWS242ServiceCatalogService.ProvisionProduct',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "ProductId": "",\n  "ProductName": "",\n  "ProvisioningArtifactId": "",\n  "ProvisioningArtifactName": "",\n  "PathId": "",\n  "PathName": "",\n  "ProvisionedProductName": "",\n  "ProvisioningParameters": "",\n  "ProvisioningPreferences": "",\n  "Tags": "",\n  "NotificationArns": "",\n  "ProvisionToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"NotificationArns\": \"\",\n  \"ProvisionToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ProvisionProduct")
  .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({
  AcceptLanguage: '',
  ProductId: '',
  ProductName: '',
  ProvisioningArtifactId: '',
  ProvisioningArtifactName: '',
  PathId: '',
  PathName: '',
  ProvisionedProductName: '',
  ProvisioningParameters: '',
  ProvisioningPreferences: '',
  Tags: '',
  NotificationArns: '',
  ProvisionToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ProvisionProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AcceptLanguage: '',
    ProductId: '',
    ProductName: '',
    ProvisioningArtifactId: '',
    ProvisioningArtifactName: '',
    PathId: '',
    PathName: '',
    ProvisionedProductName: '',
    ProvisioningParameters: '',
    ProvisioningPreferences: '',
    Tags: '',
    NotificationArns: '',
    ProvisionToken: ''
  },
  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=AWS242ServiceCatalogService.ProvisionProduct');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  ProductId: '',
  ProductName: '',
  ProvisioningArtifactId: '',
  ProvisioningArtifactName: '',
  PathId: '',
  PathName: '',
  ProvisionedProductName: '',
  ProvisioningParameters: '',
  ProvisioningPreferences: '',
  Tags: '',
  NotificationArns: '',
  ProvisionToken: ''
});

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=AWS242ServiceCatalogService.ProvisionProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    ProductId: '',
    ProductName: '',
    ProvisioningArtifactId: '',
    ProvisioningArtifactName: '',
    PathId: '',
    PathName: '',
    ProvisionedProductName: '',
    ProvisioningParameters: '',
    ProvisioningPreferences: '',
    Tags: '',
    NotificationArns: '',
    ProvisionToken: ''
  }
};

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=AWS242ServiceCatalogService.ProvisionProduct';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProductId":"","ProductName":"","ProvisioningArtifactId":"","ProvisioningArtifactName":"","PathId":"","PathName":"","ProvisionedProductName":"","ProvisioningParameters":"","ProvisioningPreferences":"","Tags":"","NotificationArns":"","ProvisionToken":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"ProductId": @"",
                              @"ProductName": @"",
                              @"ProvisioningArtifactId": @"",
                              @"ProvisioningArtifactName": @"",
                              @"PathId": @"",
                              @"PathName": @"",
                              @"ProvisionedProductName": @"",
                              @"ProvisioningParameters": @"",
                              @"ProvisioningPreferences": @"",
                              @"Tags": @"",
                              @"NotificationArns": @"",
                              @"ProvisionToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ProvisionProduct"]
                                                       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=AWS242ServiceCatalogService.ProvisionProduct" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"NotificationArns\": \"\",\n  \"ProvisionToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ProvisionProduct",
  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([
    'AcceptLanguage' => '',
    'ProductId' => '',
    'ProductName' => '',
    'ProvisioningArtifactId' => '',
    'ProvisioningArtifactName' => '',
    'PathId' => '',
    'PathName' => '',
    'ProvisionedProductName' => '',
    'ProvisioningParameters' => '',
    'ProvisioningPreferences' => '',
    'Tags' => '',
    'NotificationArns' => '',
    'ProvisionToken' => ''
  ]),
  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=AWS242ServiceCatalogService.ProvisionProduct', [
  'body' => '{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningArtifactName": "",
  "PathId": "",
  "PathName": "",
  "ProvisionedProductName": "",
  "ProvisioningParameters": "",
  "ProvisioningPreferences": "",
  "Tags": "",
  "NotificationArns": "",
  "ProvisionToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ProvisionProduct');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'ProductId' => '',
  'ProductName' => '',
  'ProvisioningArtifactId' => '',
  'ProvisioningArtifactName' => '',
  'PathId' => '',
  'PathName' => '',
  'ProvisionedProductName' => '',
  'ProvisioningParameters' => '',
  'ProvisioningPreferences' => '',
  'Tags' => '',
  'NotificationArns' => '',
  'ProvisionToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'ProductId' => '',
  'ProductName' => '',
  'ProvisioningArtifactId' => '',
  'ProvisioningArtifactName' => '',
  'PathId' => '',
  'PathName' => '',
  'ProvisionedProductName' => '',
  'ProvisioningParameters' => '',
  'ProvisioningPreferences' => '',
  'Tags' => '',
  'NotificationArns' => '',
  'ProvisionToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ProvisionProduct');
$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=AWS242ServiceCatalogService.ProvisionProduct' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningArtifactName": "",
  "PathId": "",
  "PathName": "",
  "ProvisionedProductName": "",
  "ProvisioningParameters": "",
  "ProvisioningPreferences": "",
  "Tags": "",
  "NotificationArns": "",
  "ProvisionToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ProvisionProduct' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningArtifactName": "",
  "PathId": "",
  "PathName": "",
  "ProvisionedProductName": "",
  "ProvisioningParameters": "",
  "ProvisioningPreferences": "",
  "Tags": "",
  "NotificationArns": "",
  "ProvisionToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"NotificationArns\": \"\",\n  \"ProvisionToken\": \"\"\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=AWS242ServiceCatalogService.ProvisionProduct"

payload = {
    "AcceptLanguage": "",
    "ProductId": "",
    "ProductName": "",
    "ProvisioningArtifactId": "",
    "ProvisioningArtifactName": "",
    "PathId": "",
    "PathName": "",
    "ProvisionedProductName": "",
    "ProvisioningParameters": "",
    "ProvisioningPreferences": "",
    "Tags": "",
    "NotificationArns": "",
    "ProvisionToken": ""
}
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=AWS242ServiceCatalogService.ProvisionProduct"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"NotificationArns\": \"\",\n  \"ProvisionToken\": \"\"\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=AWS242ServiceCatalogService.ProvisionProduct")

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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"NotificationArns\": \"\",\n  \"ProvisionToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"NotificationArns\": \"\",\n  \"ProvisionToken\": \"\"\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=AWS242ServiceCatalogService.ProvisionProduct";

    let payload = json!({
        "AcceptLanguage": "",
        "ProductId": "",
        "ProductName": "",
        "ProvisioningArtifactId": "",
        "ProvisioningArtifactName": "",
        "PathId": "",
        "PathName": "",
        "ProvisionedProductName": "",
        "ProvisioningParameters": "",
        "ProvisioningPreferences": "",
        "Tags": "",
        "NotificationArns": "",
        "ProvisionToken": ""
    });

    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=AWS242ServiceCatalogService.ProvisionProduct' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningArtifactName": "",
  "PathId": "",
  "PathName": "",
  "ProvisionedProductName": "",
  "ProvisioningParameters": "",
  "ProvisioningPreferences": "",
  "Tags": "",
  "NotificationArns": "",
  "ProvisionToken": ""
}'

echo '{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningArtifactName": "",
  "PathId": "",
  "PathName": "",
  "ProvisionedProductName": "",
  "ProvisioningParameters": "",
  "ProvisioningPreferences": "",
  "Tags": "",
  "NotificationArns": "",
  "ProvisionToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ProvisionProduct' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "ProductId": "",\n  "ProductName": "",\n  "ProvisioningArtifactId": "",\n  "ProvisioningArtifactName": "",\n  "PathId": "",\n  "PathName": "",\n  "ProvisionedProductName": "",\n  "ProvisioningParameters": "",\n  "ProvisioningPreferences": "",\n  "Tags": "",\n  "NotificationArns": "",\n  "ProvisionToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ProvisionProduct'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "ProductId": "",
  "ProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningArtifactName": "",
  "PathId": "",
  "PathName": "",
  "ProvisionedProductName": "",
  "ProvisioningParameters": "",
  "ProvisioningPreferences": "",
  "Tags": "",
  "NotificationArns": "",
  "ProvisionToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ProvisionProduct")! 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 RejectPortfolioShare

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.RejectPortfolioShare

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PortfolioShareType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.RejectPortfolioShare");

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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PortfolioShareType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.RejectPortfolioShare" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:AcceptLanguage ""
                                                                                                                         :PortfolioId ""
                                                                                                                         :PortfolioShareType ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.RejectPortfolioShare"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PortfolioShareType\": \"\"\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=AWS242ServiceCatalogService.RejectPortfolioShare"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PortfolioShareType\": \"\"\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=AWS242ServiceCatalogService.RejectPortfolioShare");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PortfolioShareType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.RejectPortfolioShare"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PortfolioShareType\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 75

{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PortfolioShareType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.RejectPortfolioShare")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PortfolioShareType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.RejectPortfolioShare"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PortfolioShareType\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PortfolioShareType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.RejectPortfolioShare")
  .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=AWS242ServiceCatalogService.RejectPortfolioShare")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PortfolioShareType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  PortfolioId: '',
  PortfolioShareType: ''
});

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=AWS242ServiceCatalogService.RejectPortfolioShare');
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=AWS242ServiceCatalogService.RejectPortfolioShare',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', PortfolioId: '', PortfolioShareType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.RejectPortfolioShare';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PortfolioId":"","PortfolioShareType":""}'
};

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=AWS242ServiceCatalogService.RejectPortfolioShare',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "PortfolioId": "",\n  "PortfolioShareType": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PortfolioShareType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.RejectPortfolioShare")
  .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({AcceptLanguage: '', PortfolioId: '', PortfolioShareType: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.RejectPortfolioShare',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AcceptLanguage: '', PortfolioId: '', PortfolioShareType: ''},
  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=AWS242ServiceCatalogService.RejectPortfolioShare');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  PortfolioId: '',
  PortfolioShareType: ''
});

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=AWS242ServiceCatalogService.RejectPortfolioShare',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', PortfolioId: '', PortfolioShareType: ''}
};

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=AWS242ServiceCatalogService.RejectPortfolioShare';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PortfolioId":"","PortfolioShareType":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"PortfolioId": @"",
                              @"PortfolioShareType": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.RejectPortfolioShare"]
                                                       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=AWS242ServiceCatalogService.RejectPortfolioShare" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PortfolioShareType\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.RejectPortfolioShare",
  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([
    'AcceptLanguage' => '',
    'PortfolioId' => '',
    'PortfolioShareType' => ''
  ]),
  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=AWS242ServiceCatalogService.RejectPortfolioShare', [
  'body' => '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PortfolioShareType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.RejectPortfolioShare');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'PortfolioId' => '',
  'PortfolioShareType' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'PortfolioId' => '',
  'PortfolioShareType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.RejectPortfolioShare');
$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=AWS242ServiceCatalogService.RejectPortfolioShare' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PortfolioShareType": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.RejectPortfolioShare' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PortfolioShareType": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PortfolioShareType\": \"\"\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=AWS242ServiceCatalogService.RejectPortfolioShare"

payload = {
    "AcceptLanguage": "",
    "PortfolioId": "",
    "PortfolioShareType": ""
}
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=AWS242ServiceCatalogService.RejectPortfolioShare"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PortfolioShareType\": \"\"\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=AWS242ServiceCatalogService.RejectPortfolioShare")

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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PortfolioShareType\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"PortfolioShareType\": \"\"\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=AWS242ServiceCatalogService.RejectPortfolioShare";

    let payload = json!({
        "AcceptLanguage": "",
        "PortfolioId": "",
        "PortfolioShareType": ""
    });

    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=AWS242ServiceCatalogService.RejectPortfolioShare' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PortfolioShareType": ""
}'

echo '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PortfolioShareType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.RejectPortfolioShare' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "PortfolioId": "",\n  "PortfolioShareType": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.RejectPortfolioShare'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "PortfolioId": "",
  "PortfolioShareType": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.RejectPortfolioShare")! 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 ScanProvisionedProducts

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ScanProvisionedProducts

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "AccessLevelFilter": "",
  "PageSize": "",
  "PageToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ScanProvisionedProducts");

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  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ScanProvisionedProducts" {:headers {:x-amz-target ""}
                                                                                                              :content-type :json
                                                                                                              :form-params {:AcceptLanguage ""
                                                                                                                            :AccessLevelFilter ""
                                                                                                                            :PageSize ""
                                                                                                                            :PageToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ScanProvisionedProducts"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ScanProvisionedProducts"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ScanProvisionedProducts");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ScanProvisionedProducts"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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: 90

{
  "AcceptLanguage": "",
  "AccessLevelFilter": "",
  "PageSize": "",
  "PageToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ScanProvisionedProducts")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ScanProvisionedProducts"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ScanProvisionedProducts")
  .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=AWS242ServiceCatalogService.ScanProvisionedProducts")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  AccessLevelFilter: '',
  PageSize: '',
  PageToken: ''
});

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=AWS242ServiceCatalogService.ScanProvisionedProducts');
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=AWS242ServiceCatalogService.ScanProvisionedProducts',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', AccessLevelFilter: '', PageSize: '', PageToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ScanProvisionedProducts';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","AccessLevelFilter":"","PageSize":"","PageToken":""}'
};

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=AWS242ServiceCatalogService.ScanProvisionedProducts',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "AccessLevelFilter": "",\n  "PageSize": "",\n  "PageToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ScanProvisionedProducts")
  .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({AcceptLanguage: '', AccessLevelFilter: '', PageSize: '', PageToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ScanProvisionedProducts',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AcceptLanguage: '', AccessLevelFilter: '', PageSize: '', PageToken: ''},
  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=AWS242ServiceCatalogService.ScanProvisionedProducts');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  AccessLevelFilter: '',
  PageSize: '',
  PageToken: ''
});

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=AWS242ServiceCatalogService.ScanProvisionedProducts',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', AccessLevelFilter: '', PageSize: '', PageToken: ''}
};

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=AWS242ServiceCatalogService.ScanProvisionedProducts';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","AccessLevelFilter":"","PageSize":"","PageToken":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"AccessLevelFilter": @"",
                              @"PageSize": @"",
                              @"PageToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ScanProvisionedProducts"]
                                                       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=AWS242ServiceCatalogService.ScanProvisionedProducts" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ScanProvisionedProducts",
  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([
    'AcceptLanguage' => '',
    'AccessLevelFilter' => '',
    'PageSize' => '',
    'PageToken' => ''
  ]),
  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=AWS242ServiceCatalogService.ScanProvisionedProducts', [
  'body' => '{
  "AcceptLanguage": "",
  "AccessLevelFilter": "",
  "PageSize": "",
  "PageToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ScanProvisionedProducts');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'AccessLevelFilter' => '',
  'PageSize' => '',
  'PageToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'AccessLevelFilter' => '',
  'PageSize' => '',
  'PageToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ScanProvisionedProducts');
$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=AWS242ServiceCatalogService.ScanProvisionedProducts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "AccessLevelFilter": "",
  "PageSize": "",
  "PageToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ScanProvisionedProducts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "AccessLevelFilter": "",
  "PageSize": "",
  "PageToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ScanProvisionedProducts"

payload = {
    "AcceptLanguage": "",
    "AccessLevelFilter": "",
    "PageSize": "",
    "PageToken": ""
}
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=AWS242ServiceCatalogService.ScanProvisionedProducts"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ScanProvisionedProducts")

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  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.ScanProvisionedProducts";

    let payload = json!({
        "AcceptLanguage": "",
        "AccessLevelFilter": "",
        "PageSize": "",
        "PageToken": ""
    });

    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=AWS242ServiceCatalogService.ScanProvisionedProducts' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "AccessLevelFilter": "",
  "PageSize": "",
  "PageToken": ""
}'

echo '{
  "AcceptLanguage": "",
  "AccessLevelFilter": "",
  "PageSize": "",
  "PageToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ScanProvisionedProducts' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "AccessLevelFilter": "",\n  "PageSize": "",\n  "PageToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ScanProvisionedProducts'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "AccessLevelFilter": "",
  "PageSize": "",
  "PageToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.ScanProvisionedProducts")! 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 SearchProducts

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProducts

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "Filters": "",
  "PageSize": "",
  "SortBy": "",
  "SortOrder": "",
  "PageToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProducts");

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  \"AcceptLanguage\": \"\",\n  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProducts" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:AcceptLanguage ""
                                                                                                                   :Filters ""
                                                                                                                   :PageSize ""
                                                                                                                   :SortBy ""
                                                                                                                   :SortOrder ""
                                                                                                                   :PageToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProducts"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.SearchProducts"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.SearchProducts");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProducts"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\"\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: 115

{
  "AcceptLanguage": "",
  "Filters": "",
  "PageSize": "",
  "SortBy": "",
  "SortOrder": "",
  "PageToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProducts")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProducts"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProducts")
  .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=AWS242ServiceCatalogService.SearchProducts")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  Filters: '',
  PageSize: '',
  SortBy: '',
  SortOrder: '',
  PageToken: ''
});

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=AWS242ServiceCatalogService.SearchProducts');
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=AWS242ServiceCatalogService.SearchProducts',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    Filters: '',
    PageSize: '',
    SortBy: '',
    SortOrder: '',
    PageToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProducts';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","Filters":"","PageSize":"","SortBy":"","SortOrder":"","PageToken":""}'
};

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=AWS242ServiceCatalogService.SearchProducts',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "Filters": "",\n  "PageSize": "",\n  "SortBy": "",\n  "SortOrder": "",\n  "PageToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProducts")
  .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({
  AcceptLanguage: '',
  Filters: '',
  PageSize: '',
  SortBy: '',
  SortOrder: '',
  PageToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProducts',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AcceptLanguage: '',
    Filters: '',
    PageSize: '',
    SortBy: '',
    SortOrder: '',
    PageToken: ''
  },
  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=AWS242ServiceCatalogService.SearchProducts');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  Filters: '',
  PageSize: '',
  SortBy: '',
  SortOrder: '',
  PageToken: ''
});

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=AWS242ServiceCatalogService.SearchProducts',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    Filters: '',
    PageSize: '',
    SortBy: '',
    SortOrder: '',
    PageToken: ''
  }
};

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=AWS242ServiceCatalogService.SearchProducts';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","Filters":"","PageSize":"","SortBy":"","SortOrder":"","PageToken":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"Filters": @"",
                              @"PageSize": @"",
                              @"SortBy": @"",
                              @"SortOrder": @"",
                              @"PageToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProducts"]
                                                       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=AWS242ServiceCatalogService.SearchProducts" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProducts",
  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([
    'AcceptLanguage' => '',
    'Filters' => '',
    'PageSize' => '',
    'SortBy' => '',
    'SortOrder' => '',
    'PageToken' => ''
  ]),
  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=AWS242ServiceCatalogService.SearchProducts', [
  'body' => '{
  "AcceptLanguage": "",
  "Filters": "",
  "PageSize": "",
  "SortBy": "",
  "SortOrder": "",
  "PageToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProducts');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'Filters' => '',
  'PageSize' => '',
  'SortBy' => '',
  'SortOrder' => '',
  'PageToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'Filters' => '',
  'PageSize' => '',
  'SortBy' => '',
  'SortOrder' => '',
  'PageToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProducts');
$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=AWS242ServiceCatalogService.SearchProducts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "Filters": "",
  "PageSize": "",
  "SortBy": "",
  "SortOrder": "",
  "PageToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProducts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "Filters": "",
  "PageSize": "",
  "SortBy": "",
  "SortOrder": "",
  "PageToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.SearchProducts"

payload = {
    "AcceptLanguage": "",
    "Filters": "",
    "PageSize": "",
    "SortBy": "",
    "SortOrder": "",
    "PageToken": ""
}
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=AWS242ServiceCatalogService.SearchProducts"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.SearchProducts")

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  \"AcceptLanguage\": \"\",\n  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"Filters\": \"\",\n  \"PageSize\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.SearchProducts";

    let payload = json!({
        "AcceptLanguage": "",
        "Filters": "",
        "PageSize": "",
        "SortBy": "",
        "SortOrder": "",
        "PageToken": ""
    });

    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=AWS242ServiceCatalogService.SearchProducts' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "Filters": "",
  "PageSize": "",
  "SortBy": "",
  "SortOrder": "",
  "PageToken": ""
}'

echo '{
  "AcceptLanguage": "",
  "Filters": "",
  "PageSize": "",
  "SortBy": "",
  "SortOrder": "",
  "PageToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProducts' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "Filters": "",\n  "PageSize": "",\n  "SortBy": "",\n  "SortOrder": "",\n  "PageToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProducts'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "Filters": "",
  "PageSize": "",
  "SortBy": "",
  "SortOrder": "",
  "PageToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProducts")! 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 SearchProductsAsAdmin

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProductsAsAdmin

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "Filters": "",
  "SortBy": "",
  "SortOrder": "",
  "PageToken": "",
  "PageSize": "",
  "ProductSource": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProductsAsAdmin");

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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"ProductSource\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProductsAsAdmin" {:headers {:x-amz-target ""}
                                                                                                            :content-type :json
                                                                                                            :form-params {:AcceptLanguage ""
                                                                                                                          :PortfolioId ""
                                                                                                                          :Filters ""
                                                                                                                          :SortBy ""
                                                                                                                          :SortOrder ""
                                                                                                                          :PageToken ""
                                                                                                                          :PageSize ""
                                                                                                                          :ProductSource ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProductsAsAdmin"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"ProductSource\": \"\"\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=AWS242ServiceCatalogService.SearchProductsAsAdmin"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"ProductSource\": \"\"\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=AWS242ServiceCatalogService.SearchProductsAsAdmin");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"ProductSource\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProductsAsAdmin"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"ProductSource\": \"\"\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: 159

{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "Filters": "",
  "SortBy": "",
  "SortOrder": "",
  "PageToken": "",
  "PageSize": "",
  "ProductSource": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProductsAsAdmin")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"ProductSource\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProductsAsAdmin"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"ProductSource\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"ProductSource\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProductsAsAdmin")
  .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=AWS242ServiceCatalogService.SearchProductsAsAdmin")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"ProductSource\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  PortfolioId: '',
  Filters: '',
  SortBy: '',
  SortOrder: '',
  PageToken: '',
  PageSize: '',
  ProductSource: ''
});

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=AWS242ServiceCatalogService.SearchProductsAsAdmin');
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=AWS242ServiceCatalogService.SearchProductsAsAdmin',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    PortfolioId: '',
    Filters: '',
    SortBy: '',
    SortOrder: '',
    PageToken: '',
    PageSize: '',
    ProductSource: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProductsAsAdmin';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PortfolioId":"","Filters":"","SortBy":"","SortOrder":"","PageToken":"","PageSize":"","ProductSource":""}'
};

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=AWS242ServiceCatalogService.SearchProductsAsAdmin',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "PortfolioId": "",\n  "Filters": "",\n  "SortBy": "",\n  "SortOrder": "",\n  "PageToken": "",\n  "PageSize": "",\n  "ProductSource": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"ProductSource\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProductsAsAdmin")
  .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({
  AcceptLanguage: '',
  PortfolioId: '',
  Filters: '',
  SortBy: '',
  SortOrder: '',
  PageToken: '',
  PageSize: '',
  ProductSource: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProductsAsAdmin',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AcceptLanguage: '',
    PortfolioId: '',
    Filters: '',
    SortBy: '',
    SortOrder: '',
    PageToken: '',
    PageSize: '',
    ProductSource: ''
  },
  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=AWS242ServiceCatalogService.SearchProductsAsAdmin');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  PortfolioId: '',
  Filters: '',
  SortBy: '',
  SortOrder: '',
  PageToken: '',
  PageSize: '',
  ProductSource: ''
});

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=AWS242ServiceCatalogService.SearchProductsAsAdmin',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    PortfolioId: '',
    Filters: '',
    SortBy: '',
    SortOrder: '',
    PageToken: '',
    PageSize: '',
    ProductSource: ''
  }
};

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=AWS242ServiceCatalogService.SearchProductsAsAdmin';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PortfolioId":"","Filters":"","SortBy":"","SortOrder":"","PageToken":"","PageSize":"","ProductSource":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"PortfolioId": @"",
                              @"Filters": @"",
                              @"SortBy": @"",
                              @"SortOrder": @"",
                              @"PageToken": @"",
                              @"PageSize": @"",
                              @"ProductSource": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProductsAsAdmin"]
                                                       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=AWS242ServiceCatalogService.SearchProductsAsAdmin" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"ProductSource\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProductsAsAdmin",
  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([
    'AcceptLanguage' => '',
    'PortfolioId' => '',
    'Filters' => '',
    'SortBy' => '',
    'SortOrder' => '',
    'PageToken' => '',
    'PageSize' => '',
    'ProductSource' => ''
  ]),
  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=AWS242ServiceCatalogService.SearchProductsAsAdmin', [
  'body' => '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "Filters": "",
  "SortBy": "",
  "SortOrder": "",
  "PageToken": "",
  "PageSize": "",
  "ProductSource": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProductsAsAdmin');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'PortfolioId' => '',
  'Filters' => '',
  'SortBy' => '',
  'SortOrder' => '',
  'PageToken' => '',
  'PageSize' => '',
  'ProductSource' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'PortfolioId' => '',
  'Filters' => '',
  'SortBy' => '',
  'SortOrder' => '',
  'PageToken' => '',
  'PageSize' => '',
  'ProductSource' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProductsAsAdmin');
$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=AWS242ServiceCatalogService.SearchProductsAsAdmin' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "Filters": "",
  "SortBy": "",
  "SortOrder": "",
  "PageToken": "",
  "PageSize": "",
  "ProductSource": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProductsAsAdmin' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "Filters": "",
  "SortBy": "",
  "SortOrder": "",
  "PageToken": "",
  "PageSize": "",
  "ProductSource": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"ProductSource\": \"\"\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=AWS242ServiceCatalogService.SearchProductsAsAdmin"

payload = {
    "AcceptLanguage": "",
    "PortfolioId": "",
    "Filters": "",
    "SortBy": "",
    "SortOrder": "",
    "PageToken": "",
    "PageSize": "",
    "ProductSource": ""
}
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=AWS242ServiceCatalogService.SearchProductsAsAdmin"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"ProductSource\": \"\"\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=AWS242ServiceCatalogService.SearchProductsAsAdmin")

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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"ProductSource\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageToken\": \"\",\n  \"PageSize\": \"\",\n  \"ProductSource\": \"\"\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=AWS242ServiceCatalogService.SearchProductsAsAdmin";

    let payload = json!({
        "AcceptLanguage": "",
        "PortfolioId": "",
        "Filters": "",
        "SortBy": "",
        "SortOrder": "",
        "PageToken": "",
        "PageSize": "",
        "ProductSource": ""
    });

    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=AWS242ServiceCatalogService.SearchProductsAsAdmin' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "Filters": "",
  "SortBy": "",
  "SortOrder": "",
  "PageToken": "",
  "PageSize": "",
  "ProductSource": ""
}'

echo '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "Filters": "",
  "SortBy": "",
  "SortOrder": "",
  "PageToken": "",
  "PageSize": "",
  "ProductSource": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProductsAsAdmin' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "PortfolioId": "",\n  "Filters": "",\n  "SortBy": "",\n  "SortOrder": "",\n  "PageToken": "",\n  "PageSize": "",\n  "ProductSource": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProductsAsAdmin'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "PortfolioId": "",
  "Filters": "",
  "SortBy": "",
  "SortOrder": "",
  "PageToken": "",
  "PageSize": "",
  "ProductSource": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProductsAsAdmin")! 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 SearchProvisionedProducts

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProvisionedProducts

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "AccessLevelFilter": "",
  "Filters": "",
  "SortBy": "",
  "SortOrder": "",
  "PageSize": "",
  "PageToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProvisionedProducts");

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  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProvisionedProducts" {:headers {:x-amz-target ""}
                                                                                                                :content-type :json
                                                                                                                :form-params {:AcceptLanguage ""
                                                                                                                              :AccessLevelFilter ""
                                                                                                                              :Filters ""
                                                                                                                              :SortBy ""
                                                                                                                              :SortOrder ""
                                                                                                                              :PageSize ""
                                                                                                                              :PageToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProvisionedProducts"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.SearchProvisionedProducts"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.SearchProvisionedProducts");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProvisionedProducts"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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: 142

{
  "AcceptLanguage": "",
  "AccessLevelFilter": "",
  "Filters": "",
  "SortBy": "",
  "SortOrder": "",
  "PageSize": "",
  "PageToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProvisionedProducts")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProvisionedProducts"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProvisionedProducts")
  .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=AWS242ServiceCatalogService.SearchProvisionedProducts")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  AccessLevelFilter: '',
  Filters: '',
  SortBy: '',
  SortOrder: '',
  PageSize: '',
  PageToken: ''
});

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=AWS242ServiceCatalogService.SearchProvisionedProducts');
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=AWS242ServiceCatalogService.SearchProvisionedProducts',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    AccessLevelFilter: '',
    Filters: '',
    SortBy: '',
    SortOrder: '',
    PageSize: '',
    PageToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProvisionedProducts';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","AccessLevelFilter":"","Filters":"","SortBy":"","SortOrder":"","PageSize":"","PageToken":""}'
};

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=AWS242ServiceCatalogService.SearchProvisionedProducts',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "AccessLevelFilter": "",\n  "Filters": "",\n  "SortBy": "",\n  "SortOrder": "",\n  "PageSize": "",\n  "PageToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProvisionedProducts")
  .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({
  AcceptLanguage: '',
  AccessLevelFilter: '',
  Filters: '',
  SortBy: '',
  SortOrder: '',
  PageSize: '',
  PageToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProvisionedProducts',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AcceptLanguage: '',
    AccessLevelFilter: '',
    Filters: '',
    SortBy: '',
    SortOrder: '',
    PageSize: '',
    PageToken: ''
  },
  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=AWS242ServiceCatalogService.SearchProvisionedProducts');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  AccessLevelFilter: '',
  Filters: '',
  SortBy: '',
  SortOrder: '',
  PageSize: '',
  PageToken: ''
});

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=AWS242ServiceCatalogService.SearchProvisionedProducts',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    AccessLevelFilter: '',
    Filters: '',
    SortBy: '',
    SortOrder: '',
    PageSize: '',
    PageToken: ''
  }
};

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=AWS242ServiceCatalogService.SearchProvisionedProducts';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","AccessLevelFilter":"","Filters":"","SortBy":"","SortOrder":"","PageSize":"","PageToken":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"AccessLevelFilter": @"",
                              @"Filters": @"",
                              @"SortBy": @"",
                              @"SortOrder": @"",
                              @"PageSize": @"",
                              @"PageToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProvisionedProducts"]
                                                       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=AWS242ServiceCatalogService.SearchProvisionedProducts" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProvisionedProducts",
  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([
    'AcceptLanguage' => '',
    'AccessLevelFilter' => '',
    'Filters' => '',
    'SortBy' => '',
    'SortOrder' => '',
    'PageSize' => '',
    'PageToken' => ''
  ]),
  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=AWS242ServiceCatalogService.SearchProvisionedProducts', [
  'body' => '{
  "AcceptLanguage": "",
  "AccessLevelFilter": "",
  "Filters": "",
  "SortBy": "",
  "SortOrder": "",
  "PageSize": "",
  "PageToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProvisionedProducts');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'AccessLevelFilter' => '',
  'Filters' => '',
  'SortBy' => '',
  'SortOrder' => '',
  'PageSize' => '',
  'PageToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'AccessLevelFilter' => '',
  'Filters' => '',
  'SortBy' => '',
  'SortOrder' => '',
  'PageSize' => '',
  'PageToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProvisionedProducts');
$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=AWS242ServiceCatalogService.SearchProvisionedProducts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "AccessLevelFilter": "",
  "Filters": "",
  "SortBy": "",
  "SortOrder": "",
  "PageSize": "",
  "PageToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProvisionedProducts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "AccessLevelFilter": "",
  "Filters": "",
  "SortBy": "",
  "SortOrder": "",
  "PageSize": "",
  "PageToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.SearchProvisionedProducts"

payload = {
    "AcceptLanguage": "",
    "AccessLevelFilter": "",
    "Filters": "",
    "SortBy": "",
    "SortOrder": "",
    "PageSize": "",
    "PageToken": ""
}
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=AWS242ServiceCatalogService.SearchProvisionedProducts"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.SearchProvisionedProducts")

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  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"AccessLevelFilter\": \"\",\n  \"Filters\": \"\",\n  \"SortBy\": \"\",\n  \"SortOrder\": \"\",\n  \"PageSize\": \"\",\n  \"PageToken\": \"\"\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=AWS242ServiceCatalogService.SearchProvisionedProducts";

    let payload = json!({
        "AcceptLanguage": "",
        "AccessLevelFilter": "",
        "Filters": "",
        "SortBy": "",
        "SortOrder": "",
        "PageSize": "",
        "PageToken": ""
    });

    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=AWS242ServiceCatalogService.SearchProvisionedProducts' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "AccessLevelFilter": "",
  "Filters": "",
  "SortBy": "",
  "SortOrder": "",
  "PageSize": "",
  "PageToken": ""
}'

echo '{
  "AcceptLanguage": "",
  "AccessLevelFilter": "",
  "Filters": "",
  "SortBy": "",
  "SortOrder": "",
  "PageSize": "",
  "PageToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProvisionedProducts' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "AccessLevelFilter": "",\n  "Filters": "",\n  "SortBy": "",\n  "SortOrder": "",\n  "PageSize": "",\n  "PageToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProvisionedProducts'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "AccessLevelFilter": "",
  "Filters": "",
  "SortBy": "",
  "SortOrder": "",
  "PageSize": "",
  "PageToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.SearchProvisionedProducts")! 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 TerminateProvisionedProduct

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.TerminateProvisionedProduct

HEADERS

X-Amz-Target

BODY json

{
  "ProvisionedProductName": "",
  "ProvisionedProductId": "",
  "TerminateToken": "",
  "IgnoreErrors": "",
  "AcceptLanguage": "",
  "RetainPhysicalResources": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.TerminateProvisionedProduct");

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  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"TerminateToken\": \"\",\n  \"IgnoreErrors\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"RetainPhysicalResources\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.TerminateProvisionedProduct" {:headers {:x-amz-target ""}
                                                                                                                  :content-type :json
                                                                                                                  :form-params {:ProvisionedProductName ""
                                                                                                                                :ProvisionedProductId ""
                                                                                                                                :TerminateToken ""
                                                                                                                                :IgnoreErrors ""
                                                                                                                                :AcceptLanguage ""
                                                                                                                                :RetainPhysicalResources ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.TerminateProvisionedProduct"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"TerminateToken\": \"\",\n  \"IgnoreErrors\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"RetainPhysicalResources\": \"\"\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=AWS242ServiceCatalogService.TerminateProvisionedProduct"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"TerminateToken\": \"\",\n  \"IgnoreErrors\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"RetainPhysicalResources\": \"\"\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=AWS242ServiceCatalogService.TerminateProvisionedProduct");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"TerminateToken\": \"\",\n  \"IgnoreErrors\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"RetainPhysicalResources\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.TerminateProvisionedProduct"

	payload := strings.NewReader("{\n  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"TerminateToken\": \"\",\n  \"IgnoreErrors\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"RetainPhysicalResources\": \"\"\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: 167

{
  "ProvisionedProductName": "",
  "ProvisionedProductId": "",
  "TerminateToken": "",
  "IgnoreErrors": "",
  "AcceptLanguage": "",
  "RetainPhysicalResources": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.TerminateProvisionedProduct")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"TerminateToken\": \"\",\n  \"IgnoreErrors\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"RetainPhysicalResources\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.TerminateProvisionedProduct"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"TerminateToken\": \"\",\n  \"IgnoreErrors\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"RetainPhysicalResources\": \"\"\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  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"TerminateToken\": \"\",\n  \"IgnoreErrors\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"RetainPhysicalResources\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.TerminateProvisionedProduct")
  .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=AWS242ServiceCatalogService.TerminateProvisionedProduct")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"TerminateToken\": \"\",\n  \"IgnoreErrors\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"RetainPhysicalResources\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ProvisionedProductName: '',
  ProvisionedProductId: '',
  TerminateToken: '',
  IgnoreErrors: '',
  AcceptLanguage: '',
  RetainPhysicalResources: ''
});

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=AWS242ServiceCatalogService.TerminateProvisionedProduct');
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=AWS242ServiceCatalogService.TerminateProvisionedProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ProvisionedProductName: '',
    ProvisionedProductId: '',
    TerminateToken: '',
    IgnoreErrors: '',
    AcceptLanguage: '',
    RetainPhysicalResources: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.TerminateProvisionedProduct';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ProvisionedProductName":"","ProvisionedProductId":"","TerminateToken":"","IgnoreErrors":"","AcceptLanguage":"","RetainPhysicalResources":""}'
};

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=AWS242ServiceCatalogService.TerminateProvisionedProduct',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ProvisionedProductName": "",\n  "ProvisionedProductId": "",\n  "TerminateToken": "",\n  "IgnoreErrors": "",\n  "AcceptLanguage": "",\n  "RetainPhysicalResources": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"TerminateToken\": \"\",\n  \"IgnoreErrors\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"RetainPhysicalResources\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.TerminateProvisionedProduct")
  .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({
  ProvisionedProductName: '',
  ProvisionedProductId: '',
  TerminateToken: '',
  IgnoreErrors: '',
  AcceptLanguage: '',
  RetainPhysicalResources: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.TerminateProvisionedProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ProvisionedProductName: '',
    ProvisionedProductId: '',
    TerminateToken: '',
    IgnoreErrors: '',
    AcceptLanguage: '',
    RetainPhysicalResources: ''
  },
  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=AWS242ServiceCatalogService.TerminateProvisionedProduct');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ProvisionedProductName: '',
  ProvisionedProductId: '',
  TerminateToken: '',
  IgnoreErrors: '',
  AcceptLanguage: '',
  RetainPhysicalResources: ''
});

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=AWS242ServiceCatalogService.TerminateProvisionedProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ProvisionedProductName: '',
    ProvisionedProductId: '',
    TerminateToken: '',
    IgnoreErrors: '',
    AcceptLanguage: '',
    RetainPhysicalResources: ''
  }
};

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=AWS242ServiceCatalogService.TerminateProvisionedProduct';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ProvisionedProductName":"","ProvisionedProductId":"","TerminateToken":"","IgnoreErrors":"","AcceptLanguage":"","RetainPhysicalResources":""}'
};

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 = @{ @"ProvisionedProductName": @"",
                              @"ProvisionedProductId": @"",
                              @"TerminateToken": @"",
                              @"IgnoreErrors": @"",
                              @"AcceptLanguage": @"",
                              @"RetainPhysicalResources": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.TerminateProvisionedProduct"]
                                                       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=AWS242ServiceCatalogService.TerminateProvisionedProduct" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"TerminateToken\": \"\",\n  \"IgnoreErrors\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"RetainPhysicalResources\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.TerminateProvisionedProduct",
  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([
    'ProvisionedProductName' => '',
    'ProvisionedProductId' => '',
    'TerminateToken' => '',
    'IgnoreErrors' => '',
    'AcceptLanguage' => '',
    'RetainPhysicalResources' => ''
  ]),
  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=AWS242ServiceCatalogService.TerminateProvisionedProduct', [
  'body' => '{
  "ProvisionedProductName": "",
  "ProvisionedProductId": "",
  "TerminateToken": "",
  "IgnoreErrors": "",
  "AcceptLanguage": "",
  "RetainPhysicalResources": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.TerminateProvisionedProduct');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ProvisionedProductName' => '',
  'ProvisionedProductId' => '',
  'TerminateToken' => '',
  'IgnoreErrors' => '',
  'AcceptLanguage' => '',
  'RetainPhysicalResources' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ProvisionedProductName' => '',
  'ProvisionedProductId' => '',
  'TerminateToken' => '',
  'IgnoreErrors' => '',
  'AcceptLanguage' => '',
  'RetainPhysicalResources' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.TerminateProvisionedProduct');
$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=AWS242ServiceCatalogService.TerminateProvisionedProduct' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ProvisionedProductName": "",
  "ProvisionedProductId": "",
  "TerminateToken": "",
  "IgnoreErrors": "",
  "AcceptLanguage": "",
  "RetainPhysicalResources": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.TerminateProvisionedProduct' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ProvisionedProductName": "",
  "ProvisionedProductId": "",
  "TerminateToken": "",
  "IgnoreErrors": "",
  "AcceptLanguage": "",
  "RetainPhysicalResources": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"TerminateToken\": \"\",\n  \"IgnoreErrors\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"RetainPhysicalResources\": \"\"\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=AWS242ServiceCatalogService.TerminateProvisionedProduct"

payload = {
    "ProvisionedProductName": "",
    "ProvisionedProductId": "",
    "TerminateToken": "",
    "IgnoreErrors": "",
    "AcceptLanguage": "",
    "RetainPhysicalResources": ""
}
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=AWS242ServiceCatalogService.TerminateProvisionedProduct"

payload <- "{\n  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"TerminateToken\": \"\",\n  \"IgnoreErrors\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"RetainPhysicalResources\": \"\"\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=AWS242ServiceCatalogService.TerminateProvisionedProduct")

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  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"TerminateToken\": \"\",\n  \"IgnoreErrors\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"RetainPhysicalResources\": \"\"\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  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"TerminateToken\": \"\",\n  \"IgnoreErrors\": \"\",\n  \"AcceptLanguage\": \"\",\n  \"RetainPhysicalResources\": \"\"\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=AWS242ServiceCatalogService.TerminateProvisionedProduct";

    let payload = json!({
        "ProvisionedProductName": "",
        "ProvisionedProductId": "",
        "TerminateToken": "",
        "IgnoreErrors": "",
        "AcceptLanguage": "",
        "RetainPhysicalResources": ""
    });

    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=AWS242ServiceCatalogService.TerminateProvisionedProduct' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ProvisionedProductName": "",
  "ProvisionedProductId": "",
  "TerminateToken": "",
  "IgnoreErrors": "",
  "AcceptLanguage": "",
  "RetainPhysicalResources": ""
}'

echo '{
  "ProvisionedProductName": "",
  "ProvisionedProductId": "",
  "TerminateToken": "",
  "IgnoreErrors": "",
  "AcceptLanguage": "",
  "RetainPhysicalResources": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.TerminateProvisionedProduct' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ProvisionedProductName": "",\n  "ProvisionedProductId": "",\n  "TerminateToken": "",\n  "IgnoreErrors": "",\n  "AcceptLanguage": "",\n  "RetainPhysicalResources": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.TerminateProvisionedProduct'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ProvisionedProductName": "",
  "ProvisionedProductId": "",
  "TerminateToken": "",
  "IgnoreErrors": "",
  "AcceptLanguage": "",
  "RetainPhysicalResources": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.TerminateProvisionedProduct")! 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 UpdateConstraint

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateConstraint

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "Id": "",
  "Description": "",
  "Parameters": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateConstraint");

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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Parameters\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateConstraint" {:headers {:x-amz-target ""}
                                                                                                       :content-type :json
                                                                                                       :form-params {:AcceptLanguage ""
                                                                                                                     :Id ""
                                                                                                                     :Description ""
                                                                                                                     :Parameters ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateConstraint"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Parameters\": \"\"\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=AWS242ServiceCatalogService.UpdateConstraint"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Parameters\": \"\"\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=AWS242ServiceCatalogService.UpdateConstraint");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Parameters\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateConstraint"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Parameters\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 79

{
  "AcceptLanguage": "",
  "Id": "",
  "Description": "",
  "Parameters": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateConstraint")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Parameters\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateConstraint"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Parameters\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Parameters\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateConstraint")
  .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=AWS242ServiceCatalogService.UpdateConstraint")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Parameters\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  Id: '',
  Description: '',
  Parameters: ''
});

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=AWS242ServiceCatalogService.UpdateConstraint');
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=AWS242ServiceCatalogService.UpdateConstraint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', Id: '', Description: '', Parameters: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateConstraint';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","Id":"","Description":"","Parameters":""}'
};

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=AWS242ServiceCatalogService.UpdateConstraint',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "Id": "",\n  "Description": "",\n  "Parameters": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Parameters\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateConstraint")
  .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({AcceptLanguage: '', Id: '', Description: '', Parameters: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateConstraint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AcceptLanguage: '', Id: '', Description: '', Parameters: ''},
  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=AWS242ServiceCatalogService.UpdateConstraint');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  Id: '',
  Description: '',
  Parameters: ''
});

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=AWS242ServiceCatalogService.UpdateConstraint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AcceptLanguage: '', Id: '', Description: '', Parameters: ''}
};

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=AWS242ServiceCatalogService.UpdateConstraint';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","Id":"","Description":"","Parameters":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"Id": @"",
                              @"Description": @"",
                              @"Parameters": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateConstraint"]
                                                       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=AWS242ServiceCatalogService.UpdateConstraint" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Parameters\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateConstraint",
  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([
    'AcceptLanguage' => '',
    'Id' => '',
    'Description' => '',
    'Parameters' => ''
  ]),
  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=AWS242ServiceCatalogService.UpdateConstraint', [
  'body' => '{
  "AcceptLanguage": "",
  "Id": "",
  "Description": "",
  "Parameters": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateConstraint');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'Id' => '',
  'Description' => '',
  'Parameters' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'Id' => '',
  'Description' => '',
  'Parameters' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateConstraint');
$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=AWS242ServiceCatalogService.UpdateConstraint' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "Id": "",
  "Description": "",
  "Parameters": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateConstraint' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "Id": "",
  "Description": "",
  "Parameters": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Parameters\": \"\"\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=AWS242ServiceCatalogService.UpdateConstraint"

payload = {
    "AcceptLanguage": "",
    "Id": "",
    "Description": "",
    "Parameters": ""
}
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=AWS242ServiceCatalogService.UpdateConstraint"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Parameters\": \"\"\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=AWS242ServiceCatalogService.UpdateConstraint")

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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Parameters\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Parameters\": \"\"\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=AWS242ServiceCatalogService.UpdateConstraint";

    let payload = json!({
        "AcceptLanguage": "",
        "Id": "",
        "Description": "",
        "Parameters": ""
    });

    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=AWS242ServiceCatalogService.UpdateConstraint' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "Id": "",
  "Description": "",
  "Parameters": ""
}'

echo '{
  "AcceptLanguage": "",
  "Id": "",
  "Description": "",
  "Parameters": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateConstraint' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "Id": "",\n  "Description": "",\n  "Parameters": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateConstraint'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "Id": "",
  "Description": "",
  "Parameters": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateConstraint")! 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 UpdatePortfolio

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolio

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "Id": "",
  "DisplayName": "",
  "Description": "",
  "ProviderName": "",
  "AddTags": "",
  "RemoveTags": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolio");

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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"ProviderName\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolio" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:AcceptLanguage ""
                                                                                                                    :Id ""
                                                                                                                    :DisplayName ""
                                                                                                                    :Description ""
                                                                                                                    :ProviderName ""
                                                                                                                    :AddTags ""
                                                                                                                    :RemoveTags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolio"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"ProviderName\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\"\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=AWS242ServiceCatalogService.UpdatePortfolio"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"ProviderName\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\"\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=AWS242ServiceCatalogService.UpdatePortfolio");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"ProviderName\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolio"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"ProviderName\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\"\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: 139

{
  "AcceptLanguage": "",
  "Id": "",
  "DisplayName": "",
  "Description": "",
  "ProviderName": "",
  "AddTags": "",
  "RemoveTags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolio")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"ProviderName\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolio"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"ProviderName\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"ProviderName\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolio")
  .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=AWS242ServiceCatalogService.UpdatePortfolio")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"ProviderName\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  Id: '',
  DisplayName: '',
  Description: '',
  ProviderName: '',
  AddTags: '',
  RemoveTags: ''
});

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=AWS242ServiceCatalogService.UpdatePortfolio');
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=AWS242ServiceCatalogService.UpdatePortfolio',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    Id: '',
    DisplayName: '',
    Description: '',
    ProviderName: '',
    AddTags: '',
    RemoveTags: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolio';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","Id":"","DisplayName":"","Description":"","ProviderName":"","AddTags":"","RemoveTags":""}'
};

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=AWS242ServiceCatalogService.UpdatePortfolio',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "Id": "",\n  "DisplayName": "",\n  "Description": "",\n  "ProviderName": "",\n  "AddTags": "",\n  "RemoveTags": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"ProviderName\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolio")
  .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({
  AcceptLanguage: '',
  Id: '',
  DisplayName: '',
  Description: '',
  ProviderName: '',
  AddTags: '',
  RemoveTags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolio',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AcceptLanguage: '',
    Id: '',
    DisplayName: '',
    Description: '',
    ProviderName: '',
    AddTags: '',
    RemoveTags: ''
  },
  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=AWS242ServiceCatalogService.UpdatePortfolio');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  Id: '',
  DisplayName: '',
  Description: '',
  ProviderName: '',
  AddTags: '',
  RemoveTags: ''
});

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=AWS242ServiceCatalogService.UpdatePortfolio',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    Id: '',
    DisplayName: '',
    Description: '',
    ProviderName: '',
    AddTags: '',
    RemoveTags: ''
  }
};

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=AWS242ServiceCatalogService.UpdatePortfolio';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","Id":"","DisplayName":"","Description":"","ProviderName":"","AddTags":"","RemoveTags":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"Id": @"",
                              @"DisplayName": @"",
                              @"Description": @"",
                              @"ProviderName": @"",
                              @"AddTags": @"",
                              @"RemoveTags": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolio"]
                                                       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=AWS242ServiceCatalogService.UpdatePortfolio" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"ProviderName\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolio",
  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([
    'AcceptLanguage' => '',
    'Id' => '',
    'DisplayName' => '',
    'Description' => '',
    'ProviderName' => '',
    'AddTags' => '',
    'RemoveTags' => ''
  ]),
  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=AWS242ServiceCatalogService.UpdatePortfolio', [
  'body' => '{
  "AcceptLanguage": "",
  "Id": "",
  "DisplayName": "",
  "Description": "",
  "ProviderName": "",
  "AddTags": "",
  "RemoveTags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolio');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'Id' => '',
  'DisplayName' => '',
  'Description' => '',
  'ProviderName' => '',
  'AddTags' => '',
  'RemoveTags' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'Id' => '',
  'DisplayName' => '',
  'Description' => '',
  'ProviderName' => '',
  'AddTags' => '',
  'RemoveTags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolio');
$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=AWS242ServiceCatalogService.UpdatePortfolio' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "Id": "",
  "DisplayName": "",
  "Description": "",
  "ProviderName": "",
  "AddTags": "",
  "RemoveTags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolio' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "Id": "",
  "DisplayName": "",
  "Description": "",
  "ProviderName": "",
  "AddTags": "",
  "RemoveTags": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"ProviderName\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\"\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=AWS242ServiceCatalogService.UpdatePortfolio"

payload = {
    "AcceptLanguage": "",
    "Id": "",
    "DisplayName": "",
    "Description": "",
    "ProviderName": "",
    "AddTags": "",
    "RemoveTags": ""
}
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=AWS242ServiceCatalogService.UpdatePortfolio"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"ProviderName\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\"\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=AWS242ServiceCatalogService.UpdatePortfolio")

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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"ProviderName\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\n  \"ProviderName\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\"\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=AWS242ServiceCatalogService.UpdatePortfolio";

    let payload = json!({
        "AcceptLanguage": "",
        "Id": "",
        "DisplayName": "",
        "Description": "",
        "ProviderName": "",
        "AddTags": "",
        "RemoveTags": ""
    });

    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=AWS242ServiceCatalogService.UpdatePortfolio' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "Id": "",
  "DisplayName": "",
  "Description": "",
  "ProviderName": "",
  "AddTags": "",
  "RemoveTags": ""
}'

echo '{
  "AcceptLanguage": "",
  "Id": "",
  "DisplayName": "",
  "Description": "",
  "ProviderName": "",
  "AddTags": "",
  "RemoveTags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolio' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "Id": "",\n  "DisplayName": "",\n  "Description": "",\n  "ProviderName": "",\n  "AddTags": "",\n  "RemoveTags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolio'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "Id": "",
  "DisplayName": "",
  "Description": "",
  "ProviderName": "",
  "AddTags": "",
  "RemoveTags": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolio")! 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 UpdatePortfolioShare

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolioShare

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "AccountId": "",
  "OrganizationNode": {
    "Type": "",
    "Value": ""
  },
  "ShareTagOptions": "",
  "SharePrincipals": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolioShare");

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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"AccountId\": \"\",\n  \"OrganizationNode\": {\n    \"Type\": \"\",\n    \"Value\": \"\"\n  },\n  \"ShareTagOptions\": \"\",\n  \"SharePrincipals\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolioShare" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:AcceptLanguage ""
                                                                                                                         :PortfolioId ""
                                                                                                                         :AccountId ""
                                                                                                                         :OrganizationNode {:Type ""
                                                                                                                                            :Value ""}
                                                                                                                         :ShareTagOptions ""
                                                                                                                         :SharePrincipals ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolioShare"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"AccountId\": \"\",\n  \"OrganizationNode\": {\n    \"Type\": \"\",\n    \"Value\": \"\"\n  },\n  \"ShareTagOptions\": \"\",\n  \"SharePrincipals\": \"\"\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=AWS242ServiceCatalogService.UpdatePortfolioShare"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"AccountId\": \"\",\n  \"OrganizationNode\": {\n    \"Type\": \"\",\n    \"Value\": \"\"\n  },\n  \"ShareTagOptions\": \"\",\n  \"SharePrincipals\": \"\"\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=AWS242ServiceCatalogService.UpdatePortfolioShare");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"AccountId\": \"\",\n  \"OrganizationNode\": {\n    \"Type\": \"\",\n    \"Value\": \"\"\n  },\n  \"ShareTagOptions\": \"\",\n  \"SharePrincipals\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolioShare"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"AccountId\": \"\",\n  \"OrganizationNode\": {\n    \"Type\": \"\",\n    \"Value\": \"\"\n  },\n  \"ShareTagOptions\": \"\",\n  \"SharePrincipals\": \"\"\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: 177

{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "AccountId": "",
  "OrganizationNode": {
    "Type": "",
    "Value": ""
  },
  "ShareTagOptions": "",
  "SharePrincipals": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolioShare")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"AccountId\": \"\",\n  \"OrganizationNode\": {\n    \"Type\": \"\",\n    \"Value\": \"\"\n  },\n  \"ShareTagOptions\": \"\",\n  \"SharePrincipals\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolioShare"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"AccountId\": \"\",\n  \"OrganizationNode\": {\n    \"Type\": \"\",\n    \"Value\": \"\"\n  },\n  \"ShareTagOptions\": \"\",\n  \"SharePrincipals\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"AccountId\": \"\",\n  \"OrganizationNode\": {\n    \"Type\": \"\",\n    \"Value\": \"\"\n  },\n  \"ShareTagOptions\": \"\",\n  \"SharePrincipals\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolioShare")
  .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=AWS242ServiceCatalogService.UpdatePortfolioShare")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"AccountId\": \"\",\n  \"OrganizationNode\": {\n    \"Type\": \"\",\n    \"Value\": \"\"\n  },\n  \"ShareTagOptions\": \"\",\n  \"SharePrincipals\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  PortfolioId: '',
  AccountId: '',
  OrganizationNode: {
    Type: '',
    Value: ''
  },
  ShareTagOptions: '',
  SharePrincipals: ''
});

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=AWS242ServiceCatalogService.UpdatePortfolioShare');
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=AWS242ServiceCatalogService.UpdatePortfolioShare',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    PortfolioId: '',
    AccountId: '',
    OrganizationNode: {Type: '', Value: ''},
    ShareTagOptions: '',
    SharePrincipals: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolioShare';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PortfolioId":"","AccountId":"","OrganizationNode":{"Type":"","Value":""},"ShareTagOptions":"","SharePrincipals":""}'
};

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=AWS242ServiceCatalogService.UpdatePortfolioShare',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "PortfolioId": "",\n  "AccountId": "",\n  "OrganizationNode": {\n    "Type": "",\n    "Value": ""\n  },\n  "ShareTagOptions": "",\n  "SharePrincipals": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"AccountId\": \"\",\n  \"OrganizationNode\": {\n    \"Type\": \"\",\n    \"Value\": \"\"\n  },\n  \"ShareTagOptions\": \"\",\n  \"SharePrincipals\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolioShare")
  .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({
  AcceptLanguage: '',
  PortfolioId: '',
  AccountId: '',
  OrganizationNode: {Type: '', Value: ''},
  ShareTagOptions: '',
  SharePrincipals: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolioShare',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AcceptLanguage: '',
    PortfolioId: '',
    AccountId: '',
    OrganizationNode: {Type: '', Value: ''},
    ShareTagOptions: '',
    SharePrincipals: ''
  },
  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=AWS242ServiceCatalogService.UpdatePortfolioShare');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  PortfolioId: '',
  AccountId: '',
  OrganizationNode: {
    Type: '',
    Value: ''
  },
  ShareTagOptions: '',
  SharePrincipals: ''
});

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=AWS242ServiceCatalogService.UpdatePortfolioShare',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    PortfolioId: '',
    AccountId: '',
    OrganizationNode: {Type: '', Value: ''},
    ShareTagOptions: '',
    SharePrincipals: ''
  }
};

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=AWS242ServiceCatalogService.UpdatePortfolioShare';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","PortfolioId":"","AccountId":"","OrganizationNode":{"Type":"","Value":""},"ShareTagOptions":"","SharePrincipals":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"PortfolioId": @"",
                              @"AccountId": @"",
                              @"OrganizationNode": @{ @"Type": @"", @"Value": @"" },
                              @"ShareTagOptions": @"",
                              @"SharePrincipals": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolioShare"]
                                                       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=AWS242ServiceCatalogService.UpdatePortfolioShare" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"AccountId\": \"\",\n  \"OrganizationNode\": {\n    \"Type\": \"\",\n    \"Value\": \"\"\n  },\n  \"ShareTagOptions\": \"\",\n  \"SharePrincipals\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolioShare",
  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([
    'AcceptLanguage' => '',
    'PortfolioId' => '',
    'AccountId' => '',
    'OrganizationNode' => [
        'Type' => '',
        'Value' => ''
    ],
    'ShareTagOptions' => '',
    'SharePrincipals' => ''
  ]),
  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=AWS242ServiceCatalogService.UpdatePortfolioShare', [
  'body' => '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "AccountId": "",
  "OrganizationNode": {
    "Type": "",
    "Value": ""
  },
  "ShareTagOptions": "",
  "SharePrincipals": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolioShare');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'PortfolioId' => '',
  'AccountId' => '',
  'OrganizationNode' => [
    'Type' => '',
    'Value' => ''
  ],
  'ShareTagOptions' => '',
  'SharePrincipals' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'PortfolioId' => '',
  'AccountId' => '',
  'OrganizationNode' => [
    'Type' => '',
    'Value' => ''
  ],
  'ShareTagOptions' => '',
  'SharePrincipals' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolioShare');
$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=AWS242ServiceCatalogService.UpdatePortfolioShare' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "AccountId": "",
  "OrganizationNode": {
    "Type": "",
    "Value": ""
  },
  "ShareTagOptions": "",
  "SharePrincipals": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolioShare' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "AccountId": "",
  "OrganizationNode": {
    "Type": "",
    "Value": ""
  },
  "ShareTagOptions": "",
  "SharePrincipals": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"AccountId\": \"\",\n  \"OrganizationNode\": {\n    \"Type\": \"\",\n    \"Value\": \"\"\n  },\n  \"ShareTagOptions\": \"\",\n  \"SharePrincipals\": \"\"\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=AWS242ServiceCatalogService.UpdatePortfolioShare"

payload = {
    "AcceptLanguage": "",
    "PortfolioId": "",
    "AccountId": "",
    "OrganizationNode": {
        "Type": "",
        "Value": ""
    },
    "ShareTagOptions": "",
    "SharePrincipals": ""
}
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=AWS242ServiceCatalogService.UpdatePortfolioShare"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"AccountId\": \"\",\n  \"OrganizationNode\": {\n    \"Type\": \"\",\n    \"Value\": \"\"\n  },\n  \"ShareTagOptions\": \"\",\n  \"SharePrincipals\": \"\"\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=AWS242ServiceCatalogService.UpdatePortfolioShare")

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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"AccountId\": \"\",\n  \"OrganizationNode\": {\n    \"Type\": \"\",\n    \"Value\": \"\"\n  },\n  \"ShareTagOptions\": \"\",\n  \"SharePrincipals\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"PortfolioId\": \"\",\n  \"AccountId\": \"\",\n  \"OrganizationNode\": {\n    \"Type\": \"\",\n    \"Value\": \"\"\n  },\n  \"ShareTagOptions\": \"\",\n  \"SharePrincipals\": \"\"\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=AWS242ServiceCatalogService.UpdatePortfolioShare";

    let payload = json!({
        "AcceptLanguage": "",
        "PortfolioId": "",
        "AccountId": "",
        "OrganizationNode": json!({
            "Type": "",
            "Value": ""
        }),
        "ShareTagOptions": "",
        "SharePrincipals": ""
    });

    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=AWS242ServiceCatalogService.UpdatePortfolioShare' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "AccountId": "",
  "OrganizationNode": {
    "Type": "",
    "Value": ""
  },
  "ShareTagOptions": "",
  "SharePrincipals": ""
}'

echo '{
  "AcceptLanguage": "",
  "PortfolioId": "",
  "AccountId": "",
  "OrganizationNode": {
    "Type": "",
    "Value": ""
  },
  "ShareTagOptions": "",
  "SharePrincipals": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolioShare' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "PortfolioId": "",\n  "AccountId": "",\n  "OrganizationNode": {\n    "Type": "",\n    "Value": ""\n  },\n  "ShareTagOptions": "",\n  "SharePrincipals": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolioShare'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "PortfolioId": "",
  "AccountId": "",
  "OrganizationNode": [
    "Type": "",
    "Value": ""
  ],
  "ShareTagOptions": "",
  "SharePrincipals": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdatePortfolioShare")! 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 UpdateProduct

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProduct

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "Id": "",
  "Name": "",
  "Owner": "",
  "Description": "",
  "Distributor": "",
  "SupportDescription": "",
  "SupportEmail": "",
  "SupportUrl": "",
  "AddTags": "",
  "RemoveTags": "",
  "SourceConnection": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProduct");

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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\",\n  \"SourceConnection\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProduct" {:headers {:x-amz-target ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:AcceptLanguage ""
                                                                                                                  :Id ""
                                                                                                                  :Name ""
                                                                                                                  :Owner ""
                                                                                                                  :Description ""
                                                                                                                  :Distributor ""
                                                                                                                  :SupportDescription ""
                                                                                                                  :SupportEmail ""
                                                                                                                  :SupportUrl ""
                                                                                                                  :AddTags ""
                                                                                                                  :RemoveTags ""
                                                                                                                  :SourceConnection ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProduct"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\",\n  \"SourceConnection\": \"\"\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=AWS242ServiceCatalogService.UpdateProduct"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\",\n  \"SourceConnection\": \"\"\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=AWS242ServiceCatalogService.UpdateProduct");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\",\n  \"SourceConnection\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProduct"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\",\n  \"SourceConnection\": \"\"\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: 242

{
  "AcceptLanguage": "",
  "Id": "",
  "Name": "",
  "Owner": "",
  "Description": "",
  "Distributor": "",
  "SupportDescription": "",
  "SupportEmail": "",
  "SupportUrl": "",
  "AddTags": "",
  "RemoveTags": "",
  "SourceConnection": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProduct")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\",\n  \"SourceConnection\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProduct"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\",\n  \"SourceConnection\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\",\n  \"SourceConnection\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProduct")
  .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=AWS242ServiceCatalogService.UpdateProduct")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\",\n  \"SourceConnection\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  Id: '',
  Name: '',
  Owner: '',
  Description: '',
  Distributor: '',
  SupportDescription: '',
  SupportEmail: '',
  SupportUrl: '',
  AddTags: '',
  RemoveTags: '',
  SourceConnection: ''
});

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=AWS242ServiceCatalogService.UpdateProduct');
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=AWS242ServiceCatalogService.UpdateProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    Id: '',
    Name: '',
    Owner: '',
    Description: '',
    Distributor: '',
    SupportDescription: '',
    SupportEmail: '',
    SupportUrl: '',
    AddTags: '',
    RemoveTags: '',
    SourceConnection: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProduct';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","Id":"","Name":"","Owner":"","Description":"","Distributor":"","SupportDescription":"","SupportEmail":"","SupportUrl":"","AddTags":"","RemoveTags":"","SourceConnection":""}'
};

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=AWS242ServiceCatalogService.UpdateProduct',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "Id": "",\n  "Name": "",\n  "Owner": "",\n  "Description": "",\n  "Distributor": "",\n  "SupportDescription": "",\n  "SupportEmail": "",\n  "SupportUrl": "",\n  "AddTags": "",\n  "RemoveTags": "",\n  "SourceConnection": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\",\n  \"SourceConnection\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProduct")
  .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({
  AcceptLanguage: '',
  Id: '',
  Name: '',
  Owner: '',
  Description: '',
  Distributor: '',
  SupportDescription: '',
  SupportEmail: '',
  SupportUrl: '',
  AddTags: '',
  RemoveTags: '',
  SourceConnection: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AcceptLanguage: '',
    Id: '',
    Name: '',
    Owner: '',
    Description: '',
    Distributor: '',
    SupportDescription: '',
    SupportEmail: '',
    SupportUrl: '',
    AddTags: '',
    RemoveTags: '',
    SourceConnection: ''
  },
  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=AWS242ServiceCatalogService.UpdateProduct');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  Id: '',
  Name: '',
  Owner: '',
  Description: '',
  Distributor: '',
  SupportDescription: '',
  SupportEmail: '',
  SupportUrl: '',
  AddTags: '',
  RemoveTags: '',
  SourceConnection: ''
});

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=AWS242ServiceCatalogService.UpdateProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    Id: '',
    Name: '',
    Owner: '',
    Description: '',
    Distributor: '',
    SupportDescription: '',
    SupportEmail: '',
    SupportUrl: '',
    AddTags: '',
    RemoveTags: '',
    SourceConnection: ''
  }
};

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=AWS242ServiceCatalogService.UpdateProduct';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","Id":"","Name":"","Owner":"","Description":"","Distributor":"","SupportDescription":"","SupportEmail":"","SupportUrl":"","AddTags":"","RemoveTags":"","SourceConnection":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"Id": @"",
                              @"Name": @"",
                              @"Owner": @"",
                              @"Description": @"",
                              @"Distributor": @"",
                              @"SupportDescription": @"",
                              @"SupportEmail": @"",
                              @"SupportUrl": @"",
                              @"AddTags": @"",
                              @"RemoveTags": @"",
                              @"SourceConnection": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProduct"]
                                                       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=AWS242ServiceCatalogService.UpdateProduct" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\",\n  \"SourceConnection\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProduct",
  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([
    'AcceptLanguage' => '',
    'Id' => '',
    'Name' => '',
    'Owner' => '',
    'Description' => '',
    'Distributor' => '',
    'SupportDescription' => '',
    'SupportEmail' => '',
    'SupportUrl' => '',
    'AddTags' => '',
    'RemoveTags' => '',
    'SourceConnection' => ''
  ]),
  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=AWS242ServiceCatalogService.UpdateProduct', [
  'body' => '{
  "AcceptLanguage": "",
  "Id": "",
  "Name": "",
  "Owner": "",
  "Description": "",
  "Distributor": "",
  "SupportDescription": "",
  "SupportEmail": "",
  "SupportUrl": "",
  "AddTags": "",
  "RemoveTags": "",
  "SourceConnection": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProduct');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'Id' => '',
  'Name' => '',
  'Owner' => '',
  'Description' => '',
  'Distributor' => '',
  'SupportDescription' => '',
  'SupportEmail' => '',
  'SupportUrl' => '',
  'AddTags' => '',
  'RemoveTags' => '',
  'SourceConnection' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'Id' => '',
  'Name' => '',
  'Owner' => '',
  'Description' => '',
  'Distributor' => '',
  'SupportDescription' => '',
  'SupportEmail' => '',
  'SupportUrl' => '',
  'AddTags' => '',
  'RemoveTags' => '',
  'SourceConnection' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProduct');
$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=AWS242ServiceCatalogService.UpdateProduct' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "Id": "",
  "Name": "",
  "Owner": "",
  "Description": "",
  "Distributor": "",
  "SupportDescription": "",
  "SupportEmail": "",
  "SupportUrl": "",
  "AddTags": "",
  "RemoveTags": "",
  "SourceConnection": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProduct' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "Id": "",
  "Name": "",
  "Owner": "",
  "Description": "",
  "Distributor": "",
  "SupportDescription": "",
  "SupportEmail": "",
  "SupportUrl": "",
  "AddTags": "",
  "RemoveTags": "",
  "SourceConnection": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\",\n  \"SourceConnection\": \"\"\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=AWS242ServiceCatalogService.UpdateProduct"

payload = {
    "AcceptLanguage": "",
    "Id": "",
    "Name": "",
    "Owner": "",
    "Description": "",
    "Distributor": "",
    "SupportDescription": "",
    "SupportEmail": "",
    "SupportUrl": "",
    "AddTags": "",
    "RemoveTags": "",
    "SourceConnection": ""
}
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=AWS242ServiceCatalogService.UpdateProduct"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\",\n  \"SourceConnection\": \"\"\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=AWS242ServiceCatalogService.UpdateProduct")

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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\",\n  \"SourceConnection\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Owner\": \"\",\n  \"Description\": \"\",\n  \"Distributor\": \"\",\n  \"SupportDescription\": \"\",\n  \"SupportEmail\": \"\",\n  \"SupportUrl\": \"\",\n  \"AddTags\": \"\",\n  \"RemoveTags\": \"\",\n  \"SourceConnection\": \"\"\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=AWS242ServiceCatalogService.UpdateProduct";

    let payload = json!({
        "AcceptLanguage": "",
        "Id": "",
        "Name": "",
        "Owner": "",
        "Description": "",
        "Distributor": "",
        "SupportDescription": "",
        "SupportEmail": "",
        "SupportUrl": "",
        "AddTags": "",
        "RemoveTags": "",
        "SourceConnection": ""
    });

    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=AWS242ServiceCatalogService.UpdateProduct' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "Id": "",
  "Name": "",
  "Owner": "",
  "Description": "",
  "Distributor": "",
  "SupportDescription": "",
  "SupportEmail": "",
  "SupportUrl": "",
  "AddTags": "",
  "RemoveTags": "",
  "SourceConnection": ""
}'

echo '{
  "AcceptLanguage": "",
  "Id": "",
  "Name": "",
  "Owner": "",
  "Description": "",
  "Distributor": "",
  "SupportDescription": "",
  "SupportEmail": "",
  "SupportUrl": "",
  "AddTags": "",
  "RemoveTags": "",
  "SourceConnection": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProduct' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "Id": "",\n  "Name": "",\n  "Owner": "",\n  "Description": "",\n  "Distributor": "",\n  "SupportDescription": "",\n  "SupportEmail": "",\n  "SupportUrl": "",\n  "AddTags": "",\n  "RemoveTags": "",\n  "SourceConnection": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProduct'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "Id": "",
  "Name": "",
  "Owner": "",
  "Description": "",
  "Distributor": "",
  "SupportDescription": "",
  "SupportEmail": "",
  "SupportUrl": "",
  "AddTags": "",
  "RemoveTags": "",
  "SourceConnection": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProduct")! 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 UpdateProvisionedProduct

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProduct

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "ProvisionedProductName": "",
  "ProvisionedProductId": "",
  "ProductId": "",
  "ProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningArtifactName": "",
  "PathId": "",
  "PathName": "",
  "ProvisioningParameters": "",
  "ProvisioningPreferences": "",
  "Tags": "",
  "UpdateToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProduct");

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  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"UpdateToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProduct" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:AcceptLanguage ""
                                                                                                                             :ProvisionedProductName ""
                                                                                                                             :ProvisionedProductId ""
                                                                                                                             :ProductId ""
                                                                                                                             :ProductName ""
                                                                                                                             :ProvisioningArtifactId ""
                                                                                                                             :ProvisioningArtifactName ""
                                                                                                                             :PathId ""
                                                                                                                             :PathName ""
                                                                                                                             :ProvisioningParameters ""
                                                                                                                             :ProvisioningPreferences ""
                                                                                                                             :Tags ""
                                                                                                                             :UpdateToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProduct"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"UpdateToken\": \"\"\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=AWS242ServiceCatalogService.UpdateProvisionedProduct"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"UpdateToken\": \"\"\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=AWS242ServiceCatalogService.UpdateProvisionedProduct");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"UpdateToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProduct"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"UpdateToken\": \"\"\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: 328

{
  "AcceptLanguage": "",
  "ProvisionedProductName": "",
  "ProvisionedProductId": "",
  "ProductId": "",
  "ProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningArtifactName": "",
  "PathId": "",
  "PathName": "",
  "ProvisioningParameters": "",
  "ProvisioningPreferences": "",
  "Tags": "",
  "UpdateToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProduct")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"UpdateToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProduct"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"UpdateToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"UpdateToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProduct")
  .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=AWS242ServiceCatalogService.UpdateProvisionedProduct")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"UpdateToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  ProvisionedProductName: '',
  ProvisionedProductId: '',
  ProductId: '',
  ProductName: '',
  ProvisioningArtifactId: '',
  ProvisioningArtifactName: '',
  PathId: '',
  PathName: '',
  ProvisioningParameters: '',
  ProvisioningPreferences: '',
  Tags: '',
  UpdateToken: ''
});

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=AWS242ServiceCatalogService.UpdateProvisionedProduct');
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=AWS242ServiceCatalogService.UpdateProvisionedProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    ProvisionedProductName: '',
    ProvisionedProductId: '',
    ProductId: '',
    ProductName: '',
    ProvisioningArtifactId: '',
    ProvisioningArtifactName: '',
    PathId: '',
    PathName: '',
    ProvisioningParameters: '',
    ProvisioningPreferences: '',
    Tags: '',
    UpdateToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProduct';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProvisionedProductName":"","ProvisionedProductId":"","ProductId":"","ProductName":"","ProvisioningArtifactId":"","ProvisioningArtifactName":"","PathId":"","PathName":"","ProvisioningParameters":"","ProvisioningPreferences":"","Tags":"","UpdateToken":""}'
};

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=AWS242ServiceCatalogService.UpdateProvisionedProduct',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "ProvisionedProductName": "",\n  "ProvisionedProductId": "",\n  "ProductId": "",\n  "ProductName": "",\n  "ProvisioningArtifactId": "",\n  "ProvisioningArtifactName": "",\n  "PathId": "",\n  "PathName": "",\n  "ProvisioningParameters": "",\n  "ProvisioningPreferences": "",\n  "Tags": "",\n  "UpdateToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"UpdateToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProduct")
  .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({
  AcceptLanguage: '',
  ProvisionedProductName: '',
  ProvisionedProductId: '',
  ProductId: '',
  ProductName: '',
  ProvisioningArtifactId: '',
  ProvisioningArtifactName: '',
  PathId: '',
  PathName: '',
  ProvisioningParameters: '',
  ProvisioningPreferences: '',
  Tags: '',
  UpdateToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AcceptLanguage: '',
    ProvisionedProductName: '',
    ProvisionedProductId: '',
    ProductId: '',
    ProductName: '',
    ProvisioningArtifactId: '',
    ProvisioningArtifactName: '',
    PathId: '',
    PathName: '',
    ProvisioningParameters: '',
    ProvisioningPreferences: '',
    Tags: '',
    UpdateToken: ''
  },
  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=AWS242ServiceCatalogService.UpdateProvisionedProduct');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  ProvisionedProductName: '',
  ProvisionedProductId: '',
  ProductId: '',
  ProductName: '',
  ProvisioningArtifactId: '',
  ProvisioningArtifactName: '',
  PathId: '',
  PathName: '',
  ProvisioningParameters: '',
  ProvisioningPreferences: '',
  Tags: '',
  UpdateToken: ''
});

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=AWS242ServiceCatalogService.UpdateProvisionedProduct',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    ProvisionedProductName: '',
    ProvisionedProductId: '',
    ProductId: '',
    ProductName: '',
    ProvisioningArtifactId: '',
    ProvisioningArtifactName: '',
    PathId: '',
    PathName: '',
    ProvisioningParameters: '',
    ProvisioningPreferences: '',
    Tags: '',
    UpdateToken: ''
  }
};

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=AWS242ServiceCatalogService.UpdateProvisionedProduct';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProvisionedProductName":"","ProvisionedProductId":"","ProductId":"","ProductName":"","ProvisioningArtifactId":"","ProvisioningArtifactName":"","PathId":"","PathName":"","ProvisioningParameters":"","ProvisioningPreferences":"","Tags":"","UpdateToken":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"ProvisionedProductName": @"",
                              @"ProvisionedProductId": @"",
                              @"ProductId": @"",
                              @"ProductName": @"",
                              @"ProvisioningArtifactId": @"",
                              @"ProvisioningArtifactName": @"",
                              @"PathId": @"",
                              @"PathName": @"",
                              @"ProvisioningParameters": @"",
                              @"ProvisioningPreferences": @"",
                              @"Tags": @"",
                              @"UpdateToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProduct"]
                                                       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=AWS242ServiceCatalogService.UpdateProvisionedProduct" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"UpdateToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProduct",
  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([
    'AcceptLanguage' => '',
    'ProvisionedProductName' => '',
    'ProvisionedProductId' => '',
    'ProductId' => '',
    'ProductName' => '',
    'ProvisioningArtifactId' => '',
    'ProvisioningArtifactName' => '',
    'PathId' => '',
    'PathName' => '',
    'ProvisioningParameters' => '',
    'ProvisioningPreferences' => '',
    'Tags' => '',
    'UpdateToken' => ''
  ]),
  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=AWS242ServiceCatalogService.UpdateProvisionedProduct', [
  'body' => '{
  "AcceptLanguage": "",
  "ProvisionedProductName": "",
  "ProvisionedProductId": "",
  "ProductId": "",
  "ProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningArtifactName": "",
  "PathId": "",
  "PathName": "",
  "ProvisioningParameters": "",
  "ProvisioningPreferences": "",
  "Tags": "",
  "UpdateToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProduct');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'ProvisionedProductName' => '',
  'ProvisionedProductId' => '',
  'ProductId' => '',
  'ProductName' => '',
  'ProvisioningArtifactId' => '',
  'ProvisioningArtifactName' => '',
  'PathId' => '',
  'PathName' => '',
  'ProvisioningParameters' => '',
  'ProvisioningPreferences' => '',
  'Tags' => '',
  'UpdateToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'ProvisionedProductName' => '',
  'ProvisionedProductId' => '',
  'ProductId' => '',
  'ProductName' => '',
  'ProvisioningArtifactId' => '',
  'ProvisioningArtifactName' => '',
  'PathId' => '',
  'PathName' => '',
  'ProvisioningParameters' => '',
  'ProvisioningPreferences' => '',
  'Tags' => '',
  'UpdateToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProduct');
$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=AWS242ServiceCatalogService.UpdateProvisionedProduct' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ProvisionedProductName": "",
  "ProvisionedProductId": "",
  "ProductId": "",
  "ProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningArtifactName": "",
  "PathId": "",
  "PathName": "",
  "ProvisioningParameters": "",
  "ProvisioningPreferences": "",
  "Tags": "",
  "UpdateToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProduct' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ProvisionedProductName": "",
  "ProvisionedProductId": "",
  "ProductId": "",
  "ProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningArtifactName": "",
  "PathId": "",
  "PathName": "",
  "ProvisioningParameters": "",
  "ProvisioningPreferences": "",
  "Tags": "",
  "UpdateToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"UpdateToken\": \"\"\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=AWS242ServiceCatalogService.UpdateProvisionedProduct"

payload = {
    "AcceptLanguage": "",
    "ProvisionedProductName": "",
    "ProvisionedProductId": "",
    "ProductId": "",
    "ProductName": "",
    "ProvisioningArtifactId": "",
    "ProvisioningArtifactName": "",
    "PathId": "",
    "PathName": "",
    "ProvisioningParameters": "",
    "ProvisioningPreferences": "",
    "Tags": "",
    "UpdateToken": ""
}
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=AWS242ServiceCatalogService.UpdateProvisionedProduct"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"UpdateToken\": \"\"\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=AWS242ServiceCatalogService.UpdateProvisionedProduct")

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  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"UpdateToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductName\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProductId\": \"\",\n  \"ProductName\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"ProvisioningArtifactName\": \"\",\n  \"PathId\": \"\",\n  \"PathName\": \"\",\n  \"ProvisioningParameters\": \"\",\n  \"ProvisioningPreferences\": \"\",\n  \"Tags\": \"\",\n  \"UpdateToken\": \"\"\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=AWS242ServiceCatalogService.UpdateProvisionedProduct";

    let payload = json!({
        "AcceptLanguage": "",
        "ProvisionedProductName": "",
        "ProvisionedProductId": "",
        "ProductId": "",
        "ProductName": "",
        "ProvisioningArtifactId": "",
        "ProvisioningArtifactName": "",
        "PathId": "",
        "PathName": "",
        "ProvisioningParameters": "",
        "ProvisioningPreferences": "",
        "Tags": "",
        "UpdateToken": ""
    });

    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=AWS242ServiceCatalogService.UpdateProvisionedProduct' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "ProvisionedProductName": "",
  "ProvisionedProductId": "",
  "ProductId": "",
  "ProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningArtifactName": "",
  "PathId": "",
  "PathName": "",
  "ProvisioningParameters": "",
  "ProvisioningPreferences": "",
  "Tags": "",
  "UpdateToken": ""
}'

echo '{
  "AcceptLanguage": "",
  "ProvisionedProductName": "",
  "ProvisionedProductId": "",
  "ProductId": "",
  "ProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningArtifactName": "",
  "PathId": "",
  "PathName": "",
  "ProvisioningParameters": "",
  "ProvisioningPreferences": "",
  "Tags": "",
  "UpdateToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProduct' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "ProvisionedProductName": "",\n  "ProvisionedProductId": "",\n  "ProductId": "",\n  "ProductName": "",\n  "ProvisioningArtifactId": "",\n  "ProvisioningArtifactName": "",\n  "PathId": "",\n  "PathName": "",\n  "ProvisioningParameters": "",\n  "ProvisioningPreferences": "",\n  "Tags": "",\n  "UpdateToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProduct'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "ProvisionedProductName": "",
  "ProvisionedProductId": "",
  "ProductId": "",
  "ProductName": "",
  "ProvisioningArtifactId": "",
  "ProvisioningArtifactName": "",
  "PathId": "",
  "PathName": "",
  "ProvisioningParameters": "",
  "ProvisioningPreferences": "",
  "Tags": "",
  "UpdateToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProduct")! 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 UpdateProvisionedProductProperties

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProductProperties

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "ProvisionedProductId": "",
  "ProvisionedProductProperties": "",
  "IdempotencyToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProductProperties");

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  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductProperties\": \"\",\n  \"IdempotencyToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProductProperties" {:headers {:x-amz-target ""}
                                                                                                                         :content-type :json
                                                                                                                         :form-params {:AcceptLanguage ""
                                                                                                                                       :ProvisionedProductId ""
                                                                                                                                       :ProvisionedProductProperties ""
                                                                                                                                       :IdempotencyToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProductProperties"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductProperties\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.UpdateProvisionedProductProperties"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductProperties\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.UpdateProvisionedProductProperties");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductProperties\": \"\",\n  \"IdempotencyToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProductProperties"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductProperties\": \"\",\n  \"IdempotencyToken\": \"\"\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: 120

{
  "AcceptLanguage": "",
  "ProvisionedProductId": "",
  "ProvisionedProductProperties": "",
  "IdempotencyToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProductProperties")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductProperties\": \"\",\n  \"IdempotencyToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProductProperties"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductProperties\": \"\",\n  \"IdempotencyToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductProperties\": \"\",\n  \"IdempotencyToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProductProperties")
  .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=AWS242ServiceCatalogService.UpdateProvisionedProductProperties")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductProperties\": \"\",\n  \"IdempotencyToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  ProvisionedProductId: '',
  ProvisionedProductProperties: '',
  IdempotencyToken: ''
});

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=AWS242ServiceCatalogService.UpdateProvisionedProductProperties');
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=AWS242ServiceCatalogService.UpdateProvisionedProductProperties',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    ProvisionedProductId: '',
    ProvisionedProductProperties: '',
    IdempotencyToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProductProperties';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProvisionedProductId":"","ProvisionedProductProperties":"","IdempotencyToken":""}'
};

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=AWS242ServiceCatalogService.UpdateProvisionedProductProperties',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "ProvisionedProductId": "",\n  "ProvisionedProductProperties": "",\n  "IdempotencyToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductProperties\": \"\",\n  \"IdempotencyToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProductProperties")
  .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({
  AcceptLanguage: '',
  ProvisionedProductId: '',
  ProvisionedProductProperties: '',
  IdempotencyToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProductProperties',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AcceptLanguage: '',
    ProvisionedProductId: '',
    ProvisionedProductProperties: '',
    IdempotencyToken: ''
  },
  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=AWS242ServiceCatalogService.UpdateProvisionedProductProperties');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  ProvisionedProductId: '',
  ProvisionedProductProperties: '',
  IdempotencyToken: ''
});

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=AWS242ServiceCatalogService.UpdateProvisionedProductProperties',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    ProvisionedProductId: '',
    ProvisionedProductProperties: '',
    IdempotencyToken: ''
  }
};

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=AWS242ServiceCatalogService.UpdateProvisionedProductProperties';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProvisionedProductId":"","ProvisionedProductProperties":"","IdempotencyToken":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"ProvisionedProductId": @"",
                              @"ProvisionedProductProperties": @"",
                              @"IdempotencyToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProductProperties"]
                                                       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=AWS242ServiceCatalogService.UpdateProvisionedProductProperties" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductProperties\": \"\",\n  \"IdempotencyToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProductProperties",
  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([
    'AcceptLanguage' => '',
    'ProvisionedProductId' => '',
    'ProvisionedProductProperties' => '',
    'IdempotencyToken' => ''
  ]),
  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=AWS242ServiceCatalogService.UpdateProvisionedProductProperties', [
  'body' => '{
  "AcceptLanguage": "",
  "ProvisionedProductId": "",
  "ProvisionedProductProperties": "",
  "IdempotencyToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProductProperties');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'ProvisionedProductId' => '',
  'ProvisionedProductProperties' => '',
  'IdempotencyToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'ProvisionedProductId' => '',
  'ProvisionedProductProperties' => '',
  'IdempotencyToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProductProperties');
$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=AWS242ServiceCatalogService.UpdateProvisionedProductProperties' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ProvisionedProductId": "",
  "ProvisionedProductProperties": "",
  "IdempotencyToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProductProperties' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ProvisionedProductId": "",
  "ProvisionedProductProperties": "",
  "IdempotencyToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductProperties\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.UpdateProvisionedProductProperties"

payload = {
    "AcceptLanguage": "",
    "ProvisionedProductId": "",
    "ProvisionedProductProperties": "",
    "IdempotencyToken": ""
}
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=AWS242ServiceCatalogService.UpdateProvisionedProductProperties"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductProperties\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.UpdateProvisionedProductProperties")

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  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductProperties\": \"\",\n  \"IdempotencyToken\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProvisionedProductId\": \"\",\n  \"ProvisionedProductProperties\": \"\",\n  \"IdempotencyToken\": \"\"\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=AWS242ServiceCatalogService.UpdateProvisionedProductProperties";

    let payload = json!({
        "AcceptLanguage": "",
        "ProvisionedProductId": "",
        "ProvisionedProductProperties": "",
        "IdempotencyToken": ""
    });

    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=AWS242ServiceCatalogService.UpdateProvisionedProductProperties' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "ProvisionedProductId": "",
  "ProvisionedProductProperties": "",
  "IdempotencyToken": ""
}'

echo '{
  "AcceptLanguage": "",
  "ProvisionedProductId": "",
  "ProvisionedProductProperties": "",
  "IdempotencyToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProductProperties' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "ProvisionedProductId": "",\n  "ProvisionedProductProperties": "",\n  "IdempotencyToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProductProperties'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "ProvisionedProductId": "",
  "ProvisionedProductProperties": "",
  "IdempotencyToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisionedProductProperties")! 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 UpdateProvisioningArtifact

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisioningArtifact

HEADERS

X-Amz-Target

BODY json

{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "Name": "",
  "Description": "",
  "Active": "",
  "Guidance": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisioningArtifact");

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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Active\": \"\",\n  \"Guidance\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisioningArtifact" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:AcceptLanguage ""
                                                                                                                               :ProductId ""
                                                                                                                               :ProvisioningArtifactId ""
                                                                                                                               :Name ""
                                                                                                                               :Description ""
                                                                                                                               :Active ""
                                                                                                                               :Guidance ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisioningArtifact"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Active\": \"\",\n  \"Guidance\": \"\"\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=AWS242ServiceCatalogService.UpdateProvisioningArtifact"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Active\": \"\",\n  \"Guidance\": \"\"\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=AWS242ServiceCatalogService.UpdateProvisioningArtifact");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Active\": \"\",\n  \"Guidance\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisioningArtifact"

	payload := strings.NewReader("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Active\": \"\",\n  \"Guidance\": \"\"\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

{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "Name": "",
  "Description": "",
  "Active": "",
  "Guidance": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisioningArtifact")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Active\": \"\",\n  \"Guidance\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisioningArtifact"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Active\": \"\",\n  \"Guidance\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Active\": \"\",\n  \"Guidance\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisioningArtifact")
  .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=AWS242ServiceCatalogService.UpdateProvisioningArtifact")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Active\": \"\",\n  \"Guidance\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AcceptLanguage: '',
  ProductId: '',
  ProvisioningArtifactId: '',
  Name: '',
  Description: '',
  Active: '',
  Guidance: ''
});

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=AWS242ServiceCatalogService.UpdateProvisioningArtifact');
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=AWS242ServiceCatalogService.UpdateProvisioningArtifact',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    ProductId: '',
    ProvisioningArtifactId: '',
    Name: '',
    Description: '',
    Active: '',
    Guidance: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisioningArtifact';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProductId":"","ProvisioningArtifactId":"","Name":"","Description":"","Active":"","Guidance":""}'
};

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=AWS242ServiceCatalogService.UpdateProvisioningArtifact',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AcceptLanguage": "",\n  "ProductId": "",\n  "ProvisioningArtifactId": "",\n  "Name": "",\n  "Description": "",\n  "Active": "",\n  "Guidance": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Active\": \"\",\n  \"Guidance\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisioningArtifact")
  .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({
  AcceptLanguage: '',
  ProductId: '',
  ProvisioningArtifactId: '',
  Name: '',
  Description: '',
  Active: '',
  Guidance: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisioningArtifact',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AcceptLanguage: '',
    ProductId: '',
    ProvisioningArtifactId: '',
    Name: '',
    Description: '',
    Active: '',
    Guidance: ''
  },
  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=AWS242ServiceCatalogService.UpdateProvisioningArtifact');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AcceptLanguage: '',
  ProductId: '',
  ProvisioningArtifactId: '',
  Name: '',
  Description: '',
  Active: '',
  Guidance: ''
});

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=AWS242ServiceCatalogService.UpdateProvisioningArtifact',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AcceptLanguage: '',
    ProductId: '',
    ProvisioningArtifactId: '',
    Name: '',
    Description: '',
    Active: '',
    Guidance: ''
  }
};

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=AWS242ServiceCatalogService.UpdateProvisioningArtifact';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AcceptLanguage":"","ProductId":"","ProvisioningArtifactId":"","Name":"","Description":"","Active":"","Guidance":""}'
};

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 = @{ @"AcceptLanguage": @"",
                              @"ProductId": @"",
                              @"ProvisioningArtifactId": @"",
                              @"Name": @"",
                              @"Description": @"",
                              @"Active": @"",
                              @"Guidance": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisioningArtifact"]
                                                       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=AWS242ServiceCatalogService.UpdateProvisioningArtifact" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Active\": \"\",\n  \"Guidance\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisioningArtifact",
  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([
    'AcceptLanguage' => '',
    'ProductId' => '',
    'ProvisioningArtifactId' => '',
    'Name' => '',
    'Description' => '',
    'Active' => '',
    'Guidance' => ''
  ]),
  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=AWS242ServiceCatalogService.UpdateProvisioningArtifact', [
  'body' => '{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "Name": "",
  "Description": "",
  "Active": "",
  "Guidance": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisioningArtifact');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AcceptLanguage' => '',
  'ProductId' => '',
  'ProvisioningArtifactId' => '',
  'Name' => '',
  'Description' => '',
  'Active' => '',
  'Guidance' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AcceptLanguage' => '',
  'ProductId' => '',
  'ProvisioningArtifactId' => '',
  'Name' => '',
  'Description' => '',
  'Active' => '',
  'Guidance' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisioningArtifact');
$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=AWS242ServiceCatalogService.UpdateProvisioningArtifact' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "Name": "",
  "Description": "",
  "Active": "",
  "Guidance": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisioningArtifact' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "Name": "",
  "Description": "",
  "Active": "",
  "Guidance": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Active\": \"\",\n  \"Guidance\": \"\"\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=AWS242ServiceCatalogService.UpdateProvisioningArtifact"

payload = {
    "AcceptLanguage": "",
    "ProductId": "",
    "ProvisioningArtifactId": "",
    "Name": "",
    "Description": "",
    "Active": "",
    "Guidance": ""
}
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=AWS242ServiceCatalogService.UpdateProvisioningArtifact"

payload <- "{\n  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Active\": \"\",\n  \"Guidance\": \"\"\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=AWS242ServiceCatalogService.UpdateProvisioningArtifact")

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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Active\": \"\",\n  \"Guidance\": \"\"\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  \"AcceptLanguage\": \"\",\n  \"ProductId\": \"\",\n  \"ProvisioningArtifactId\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Active\": \"\",\n  \"Guidance\": \"\"\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=AWS242ServiceCatalogService.UpdateProvisioningArtifact";

    let payload = json!({
        "AcceptLanguage": "",
        "ProductId": "",
        "ProvisioningArtifactId": "",
        "Name": "",
        "Description": "",
        "Active": "",
        "Guidance": ""
    });

    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=AWS242ServiceCatalogService.UpdateProvisioningArtifact' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "Name": "",
  "Description": "",
  "Active": "",
  "Guidance": ""
}'

echo '{
  "AcceptLanguage": "",
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "Name": "",
  "Description": "",
  "Active": "",
  "Guidance": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisioningArtifact' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AcceptLanguage": "",\n  "ProductId": "",\n  "ProvisioningArtifactId": "",\n  "Name": "",\n  "Description": "",\n  "Active": "",\n  "Guidance": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisioningArtifact'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AcceptLanguage": "",
  "ProductId": "",
  "ProvisioningArtifactId": "",
  "Name": "",
  "Description": "",
  "Active": "",
  "Guidance": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateProvisioningArtifact")! 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 UpdateServiceAction

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateServiceAction

HEADERS

X-Amz-Target

BODY json

{
  "Id": "",
  "Name": "",
  "Definition": "",
  "Description": "",
  "AcceptLanguage": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateServiceAction");

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  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Definition\": \"\",\n  \"Description\": \"\",\n  \"AcceptLanguage\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateServiceAction" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:Id ""
                                                                                                                        :Name ""
                                                                                                                        :Definition ""
                                                                                                                        :Description ""
                                                                                                                        :AcceptLanguage ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateServiceAction"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Definition\": \"\",\n  \"Description\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.UpdateServiceAction"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Definition\": \"\",\n  \"Description\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.UpdateServiceAction");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Definition\": \"\",\n  \"Description\": \"\",\n  \"AcceptLanguage\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateServiceAction"

	payload := strings.NewReader("{\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Definition\": \"\",\n  \"Description\": \"\",\n  \"AcceptLanguage\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 93

{
  "Id": "",
  "Name": "",
  "Definition": "",
  "Description": "",
  "AcceptLanguage": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateServiceAction")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Definition\": \"\",\n  \"Description\": \"\",\n  \"AcceptLanguage\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateServiceAction"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Definition\": \"\",\n  \"Description\": \"\",\n  \"AcceptLanguage\": \"\"\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  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Definition\": \"\",\n  \"Description\": \"\",\n  \"AcceptLanguage\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateServiceAction")
  .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=AWS242ServiceCatalogService.UpdateServiceAction")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Definition\": \"\",\n  \"Description\": \"\",\n  \"AcceptLanguage\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Id: '',
  Name: '',
  Definition: '',
  Description: '',
  AcceptLanguage: ''
});

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=AWS242ServiceCatalogService.UpdateServiceAction');
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=AWS242ServiceCatalogService.UpdateServiceAction',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Id: '', Name: '', Definition: '', Description: '', AcceptLanguage: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateServiceAction';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Id":"","Name":"","Definition":"","Description":"","AcceptLanguage":""}'
};

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=AWS242ServiceCatalogService.UpdateServiceAction',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Id": "",\n  "Name": "",\n  "Definition": "",\n  "Description": "",\n  "AcceptLanguage": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Definition\": \"\",\n  \"Description\": \"\",\n  \"AcceptLanguage\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateServiceAction")
  .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({Id: '', Name: '', Definition: '', Description: '', AcceptLanguage: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateServiceAction',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Id: '', Name: '', Definition: '', Description: '', AcceptLanguage: ''},
  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=AWS242ServiceCatalogService.UpdateServiceAction');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Id: '',
  Name: '',
  Definition: '',
  Description: '',
  AcceptLanguage: ''
});

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=AWS242ServiceCatalogService.UpdateServiceAction',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Id: '', Name: '', Definition: '', Description: '', AcceptLanguage: ''}
};

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=AWS242ServiceCatalogService.UpdateServiceAction';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Id":"","Name":"","Definition":"","Description":"","AcceptLanguage":""}'
};

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 = @{ @"Id": @"",
                              @"Name": @"",
                              @"Definition": @"",
                              @"Description": @"",
                              @"AcceptLanguage": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateServiceAction"]
                                                       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=AWS242ServiceCatalogService.UpdateServiceAction" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Definition\": \"\",\n  \"Description\": \"\",\n  \"AcceptLanguage\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateServiceAction",
  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([
    'Id' => '',
    'Name' => '',
    'Definition' => '',
    'Description' => '',
    'AcceptLanguage' => ''
  ]),
  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=AWS242ServiceCatalogService.UpdateServiceAction', [
  'body' => '{
  "Id": "",
  "Name": "",
  "Definition": "",
  "Description": "",
  "AcceptLanguage": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateServiceAction');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Id' => '',
  'Name' => '',
  'Definition' => '',
  'Description' => '',
  'AcceptLanguage' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Id' => '',
  'Name' => '',
  'Definition' => '',
  'Description' => '',
  'AcceptLanguage' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateServiceAction');
$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=AWS242ServiceCatalogService.UpdateServiceAction' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Id": "",
  "Name": "",
  "Definition": "",
  "Description": "",
  "AcceptLanguage": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateServiceAction' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Id": "",
  "Name": "",
  "Definition": "",
  "Description": "",
  "AcceptLanguage": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Definition\": \"\",\n  \"Description\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.UpdateServiceAction"

payload = {
    "Id": "",
    "Name": "",
    "Definition": "",
    "Description": "",
    "AcceptLanguage": ""
}
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=AWS242ServiceCatalogService.UpdateServiceAction"

payload <- "{\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Definition\": \"\",\n  \"Description\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.UpdateServiceAction")

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  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Definition\": \"\",\n  \"Description\": \"\",\n  \"AcceptLanguage\": \"\"\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  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Definition\": \"\",\n  \"Description\": \"\",\n  \"AcceptLanguage\": \"\"\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=AWS242ServiceCatalogService.UpdateServiceAction";

    let payload = json!({
        "Id": "",
        "Name": "",
        "Definition": "",
        "Description": "",
        "AcceptLanguage": ""
    });

    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=AWS242ServiceCatalogService.UpdateServiceAction' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Id": "",
  "Name": "",
  "Definition": "",
  "Description": "",
  "AcceptLanguage": ""
}'

echo '{
  "Id": "",
  "Name": "",
  "Definition": "",
  "Description": "",
  "AcceptLanguage": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateServiceAction' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Id": "",\n  "Name": "",\n  "Definition": "",\n  "Description": "",\n  "AcceptLanguage": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateServiceAction'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Id": "",
  "Name": "",
  "Definition": "",
  "Description": "",
  "AcceptLanguage": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateServiceAction")! 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 UpdateTagOption

{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateTagOption

HEADERS

X-Amz-Target

BODY json

{
  "Id": "",
  "Value": "",
  "Active": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateTagOption");

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  \"Id\": \"\",\n  \"Value\": \"\",\n  \"Active\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateTagOption" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:Id ""
                                                                                                                    :Value ""
                                                                                                                    :Active ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateTagOption"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Id\": \"\",\n  \"Value\": \"\",\n  \"Active\": \"\"\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=AWS242ServiceCatalogService.UpdateTagOption"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Id\": \"\",\n  \"Value\": \"\",\n  \"Active\": \"\"\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=AWS242ServiceCatalogService.UpdateTagOption");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Id\": \"\",\n  \"Value\": \"\",\n  \"Active\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateTagOption"

	payload := strings.NewReader("{\n  \"Id\": \"\",\n  \"Value\": \"\",\n  \"Active\": \"\"\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

{
  "Id": "",
  "Value": "",
  "Active": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateTagOption")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Id\": \"\",\n  \"Value\": \"\",\n  \"Active\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateTagOption"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Id\": \"\",\n  \"Value\": \"\",\n  \"Active\": \"\"\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  \"Id\": \"\",\n  \"Value\": \"\",\n  \"Active\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateTagOption")
  .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=AWS242ServiceCatalogService.UpdateTagOption")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Id\": \"\",\n  \"Value\": \"\",\n  \"Active\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Id: '',
  Value: '',
  Active: ''
});

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=AWS242ServiceCatalogService.UpdateTagOption');
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=AWS242ServiceCatalogService.UpdateTagOption',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Id: '', Value: '', Active: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateTagOption';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Id":"","Value":"","Active":""}'
};

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=AWS242ServiceCatalogService.UpdateTagOption',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Id": "",\n  "Value": "",\n  "Active": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Id\": \"\",\n  \"Value\": \"\",\n  \"Active\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateTagOption")
  .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({Id: '', Value: '', Active: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateTagOption',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Id: '', Value: '', Active: ''},
  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=AWS242ServiceCatalogService.UpdateTagOption');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Id: '',
  Value: '',
  Active: ''
});

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=AWS242ServiceCatalogService.UpdateTagOption',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Id: '', Value: '', Active: ''}
};

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=AWS242ServiceCatalogService.UpdateTagOption';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Id":"","Value":"","Active":""}'
};

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 = @{ @"Id": @"",
                              @"Value": @"",
                              @"Active": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateTagOption"]
                                                       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=AWS242ServiceCatalogService.UpdateTagOption" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Id\": \"\",\n  \"Value\": \"\",\n  \"Active\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateTagOption",
  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([
    'Id' => '',
    'Value' => '',
    'Active' => ''
  ]),
  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=AWS242ServiceCatalogService.UpdateTagOption', [
  'body' => '{
  "Id": "",
  "Value": "",
  "Active": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateTagOption');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Id' => '',
  'Value' => '',
  'Active' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Id' => '',
  'Value' => '',
  'Active' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateTagOption');
$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=AWS242ServiceCatalogService.UpdateTagOption' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Id": "",
  "Value": "",
  "Active": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateTagOption' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Id": "",
  "Value": "",
  "Active": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Id\": \"\",\n  \"Value\": \"\",\n  \"Active\": \"\"\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=AWS242ServiceCatalogService.UpdateTagOption"

payload = {
    "Id": "",
    "Value": "",
    "Active": ""
}
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=AWS242ServiceCatalogService.UpdateTagOption"

payload <- "{\n  \"Id\": \"\",\n  \"Value\": \"\",\n  \"Active\": \"\"\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=AWS242ServiceCatalogService.UpdateTagOption")

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  \"Id\": \"\",\n  \"Value\": \"\",\n  \"Active\": \"\"\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  \"Id\": \"\",\n  \"Value\": \"\",\n  \"Active\": \"\"\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=AWS242ServiceCatalogService.UpdateTagOption";

    let payload = json!({
        "Id": "",
        "Value": "",
        "Active": ""
    });

    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=AWS242ServiceCatalogService.UpdateTagOption' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Id": "",
  "Value": "",
  "Active": ""
}'

echo '{
  "Id": "",
  "Value": "",
  "Active": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateTagOption' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Id": "",\n  "Value": "",\n  "Active": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateTagOption'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Id": "",
  "Value": "",
  "Active": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWS242ServiceCatalogService.UpdateTagOption")! 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()