CURL *hnd = curl_easy_init();

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

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  \"SourceArn\": \"\",\n  \"DestinationArn\": \"\",\n  \"AssociationType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.AddAssociation" {:headers {:x-amz-target ""}
                                                                                   :content-type :json
                                                                                   :form-params {:SourceArn ""
                                                                                                 :DestinationArn ""
                                                                                                 :AssociationType ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SageMaker.AddAssociation"

	payload := strings.NewReader("{\n  \"SourceArn\": \"\",\n  \"DestinationArn\": \"\",\n  \"AssociationType\": \"\"\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: 70

{
  "SourceArn": "",
  "DestinationArn": "",
  "AssociationType": ""
}

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

client.close();

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

const data = JSON.stringify({
  SourceArn: '',
  DestinationArn: '',
  AssociationType: ''
});

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=SageMaker.AddAssociation');
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=SageMaker.AddAssociation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {SourceArn: '', DestinationArn: '', AssociationType: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.AddAssociation';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SourceArn":"","DestinationArn":"","AssociationType":""}'
};

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  SourceArn: '',
  DestinationArn: '',
  AssociationType: ''
});

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=SageMaker.AddAssociation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {SourceArn: '', DestinationArn: '', AssociationType: ''}
};

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=SageMaker.AddAssociation';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SourceArn":"","DestinationArn":"","AssociationType":""}'
};

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 = @{ @"SourceArn": @"",
                              @"DestinationArn": @"",
                              @"AssociationType": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'SourceArn' => '',
  'DestinationArn' => '',
  'AssociationType' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"SourceArn\": \"\",\n  \"DestinationArn\": \"\",\n  \"AssociationType\": \"\"\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=SageMaker.AddAssociation"

payload = {
    "SourceArn": "",
    "DestinationArn": "",
    "AssociationType": ""
}
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=SageMaker.AddAssociation"

payload <- "{\n  \"SourceArn\": \"\",\n  \"DestinationArn\": \"\",\n  \"AssociationType\": \"\"\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=SageMaker.AddAssociation")

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  \"SourceArn\": \"\",\n  \"DestinationArn\": \"\",\n  \"AssociationType\": \"\"\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  \"SourceArn\": \"\",\n  \"DestinationArn\": \"\",\n  \"AssociationType\": \"\"\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=SageMaker.AddAssociation";

    let payload = json!({
        "SourceArn": "",
        "DestinationArn": "",
        "AssociationType": ""
    });

    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);
}

echo '{
  "SourceArn": "",
  "DestinationArn": "",
  "AssociationType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.AddAssociation' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "SourceArn": "",\n  "DestinationArn": "",\n  "AssociationType": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.AddAssociation'

import Foundation

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

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

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

CURL *hnd = curl_easy_init();

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.AddTags" {:headers {:x-amz-target ""}
                                                                            :content-type :json
                                                                            :form-params {:ResourceArn ""
                                                                                          :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.AddTags"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SageMaker.AddTags"

	payload := strings.NewReader("{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}")

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

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

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

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

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

}

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

{
  "ResourceArn": "",
  "Tags": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.AddTags")
  .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=SageMaker.AddTags")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ResourceArn: '',
  Tags: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=SageMaker.AddTags');
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=SageMaker.AddTags',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: '', Tags: ''}
};

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

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

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.AddTags',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ResourceArn": "",\n  "Tags": ""\n}'
};

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({ResourceArn: '', Tags: ''}));
req.end();

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  ResourceArn: '',
  Tags: ''
});

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

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

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

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

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

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

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

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

#import 

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

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

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

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

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

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

curl_close($curl);

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.AddTags"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SageMaker.AddTags"

payload <- "{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "ResourceArn": "",
        "Tags": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "ResourceArn": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.AddTags' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.AssociateTrialComponent" {:headers {:x-amz-target ""}
                                                                                            :content-type :json
                                                                                            :form-params {:TrialComponentName ""
                                                                                                          :TrialName ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SageMaker.AssociateTrialComponent"

	payload := strings.NewReader("{\n  \"TrialComponentName\": \"\",\n  \"TrialName\": \"\"\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: 49

{
  "TrialComponentName": "",
  "TrialName": ""
}

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

client.close();

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

const data = JSON.stringify({
  TrialComponentName: '',
  TrialName: ''
});

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=SageMaker.AssociateTrialComponent');
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=SageMaker.AssociateTrialComponent',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TrialComponentName: '', TrialName: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  TrialComponentName: '',
  TrialName: ''
});

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=SageMaker.AssociateTrialComponent',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TrialComponentName: '', TrialName: ''}
};

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"TrialComponentName\": \"\",\n  \"TrialName\": \"\"\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=SageMaker.AssociateTrialComponent"

payload = {
    "TrialComponentName": "",
    "TrialName": ""
}
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=SageMaker.AssociateTrialComponent"

payload <- "{\n  \"TrialComponentName\": \"\",\n  \"TrialName\": \"\"\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=SageMaker.AssociateTrialComponent")

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  \"TrialComponentName\": \"\",\n  \"TrialName\": \"\"\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  \"TrialComponentName\": \"\",\n  \"TrialName\": \"\"\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=SageMaker.AssociateTrialComponent";

    let payload = json!({
        "TrialComponentName": "",
        "TrialName": ""
    });

    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);
}

echo '{
  "TrialComponentName": "",
  "TrialName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.AssociateTrialComponent' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SageMaker.BatchDescribeModelPackage"

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

{
  "ModelPackageArnList": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"ModelPackageArnList\": \"\"\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=SageMaker.BatchDescribeModelPackage"

payload = { "ModelPackageArnList": "" }
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=SageMaker.BatchDescribeModelPackage"

payload <- "{\n  \"ModelPackageArnList\": \"\"\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=SageMaker.BatchDescribeModelPackage")

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  \"ModelPackageArnList\": \"\"\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  \"ModelPackageArnList\": \"\"\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=SageMaker.BatchDescribeModelPackage";

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

    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);
}

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

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

import Foundation

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

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

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

CURL *hnd = curl_easy_init();

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

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  \"ActionName\": \"\",\n  \"Source\": \"\",\n  \"ActionType\": \"\",\n  \"Description\": \"\",\n  \"Status\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAction" {:headers {:x-amz-target ""}
                                                                                 :content-type :json
                                                                                 :form-params {:ActionName ""
                                                                                               :Source ""
                                                                                               :ActionType ""
                                                                                               :Description ""
                                                                                               :Status ""
                                                                                               :Properties ""
                                                                                               :MetadataProperties {:CommitId ""
                                                                                                                    :Repository ""
                                                                                                                    :GeneratedBy ""
                                                                                                                    :ProjectId ""}
                                                                                               :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAction"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ActionName\": \"\",\n  \"Source\": \"\",\n  \"ActionType\": \"\",\n  \"Description\": \"\",\n  \"Status\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\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=SageMaker.CreateAction"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ActionName\": \"\",\n  \"Source\": \"\",\n  \"ActionType\": \"\",\n  \"Description\": \"\",\n  \"Status\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\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=SageMaker.CreateAction");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ActionName\": \"\",\n  \"Source\": \"\",\n  \"ActionType\": \"\",\n  \"Description\": \"\",\n  \"Status\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\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=SageMaker.CreateAction"

	payload := strings.NewReader("{\n  \"ActionName\": \"\",\n  \"Source\": \"\",\n  \"ActionType\": \"\",\n  \"Description\": \"\",\n  \"Status\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\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: 245

{
  "ActionName": "",
  "Source": "",
  "ActionType": "",
  "Description": "",
  "Status": "",
  "Properties": "",
  "MetadataProperties": {
    "CommitId": "",
    "Repository": "",
    "GeneratedBy": "",
    "ProjectId": ""
  },
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAction")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ActionName\": \"\",\n  \"Source\": \"\",\n  \"ActionType\": \"\",\n  \"Description\": \"\",\n  \"Status\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAction"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ActionName\": \"\",\n  \"Source\": \"\",\n  \"ActionType\": \"\",\n  \"Description\": \"\",\n  \"Status\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\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  \"ActionName\": \"\",\n  \"Source\": \"\",\n  \"ActionType\": \"\",\n  \"Description\": \"\",\n  \"Status\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAction")
  .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=SageMaker.CreateAction")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ActionName\": \"\",\n  \"Source\": \"\",\n  \"ActionType\": \"\",\n  \"Description\": \"\",\n  \"Status\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ActionName: '',
  Source: '',
  ActionType: '',
  Description: '',
  Status: '',
  Properties: '',
  MetadataProperties: {
    CommitId: '',
    Repository: '',
    GeneratedBy: '',
    ProjectId: ''
  },
  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=SageMaker.CreateAction');
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=SageMaker.CreateAction',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ActionName: '',
    Source: '',
    ActionType: '',
    Description: '',
    Status: '',
    Properties: '',
    MetadataProperties: {CommitId: '', Repository: '', GeneratedBy: '', ProjectId: ''},
    Tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAction';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ActionName":"","Source":"","ActionType":"","Description":"","Status":"","Properties":"","MetadataProperties":{"CommitId":"","Repository":"","GeneratedBy":"","ProjectId":""},"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=SageMaker.CreateAction',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ActionName": "",\n  "Source": "",\n  "ActionType": "",\n  "Description": "",\n  "Status": "",\n  "Properties": "",\n  "MetadataProperties": {\n    "CommitId": "",\n    "Repository": "",\n    "GeneratedBy": "",\n    "ProjectId": ""\n  },\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  \"ActionName\": \"\",\n  \"Source\": \"\",\n  \"ActionType\": \"\",\n  \"Description\": \"\",\n  \"Status\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAction")
  .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({
  ActionName: '',
  Source: '',
  ActionType: '',
  Description: '',
  Status: '',
  Properties: '',
  MetadataProperties: {CommitId: '', Repository: '', GeneratedBy: '', ProjectId: ''},
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAction',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ActionName: '',
    Source: '',
    ActionType: '',
    Description: '',
    Status: '',
    Properties: '',
    MetadataProperties: {CommitId: '', Repository: '', GeneratedBy: '', ProjectId: ''},
    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=SageMaker.CreateAction');

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

req.type('json');
req.send({
  ActionName: '',
  Source: '',
  ActionType: '',
  Description: '',
  Status: '',
  Properties: '',
  MetadataProperties: {
    CommitId: '',
    Repository: '',
    GeneratedBy: '',
    ProjectId: ''
  },
  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=SageMaker.CreateAction',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ActionName: '',
    Source: '',
    ActionType: '',
    Description: '',
    Status: '',
    Properties: '',
    MetadataProperties: {CommitId: '', Repository: '', GeneratedBy: '', ProjectId: ''},
    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=SageMaker.CreateAction';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ActionName":"","Source":"","ActionType":"","Description":"","Status":"","Properties":"","MetadataProperties":{"CommitId":"","Repository":"","GeneratedBy":"","ProjectId":""},"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 = @{ @"ActionName": @"",
                              @"Source": @"",
                              @"ActionType": @"",
                              @"Description": @"",
                              @"Status": @"",
                              @"Properties": @"",
                              @"MetadataProperties": @{ @"CommitId": @"", @"Repository": @"", @"GeneratedBy": @"", @"ProjectId": @"" },
                              @"Tags": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAction"]
                                                       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=SageMaker.CreateAction" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ActionName\": \"\",\n  \"Source\": \"\",\n  \"ActionType\": \"\",\n  \"Description\": \"\",\n  \"Status\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\n  \"Tags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAction",
  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([
    'ActionName' => '',
    'Source' => '',
    'ActionType' => '',
    'Description' => '',
    'Status' => '',
    'Properties' => '',
    'MetadataProperties' => [
        'CommitId' => '',
        'Repository' => '',
        'GeneratedBy' => '',
        'ProjectId' => ''
    ],
    '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=SageMaker.CreateAction', [
  'body' => '{
  "ActionName": "",
  "Source": "",
  "ActionType": "",
  "Description": "",
  "Status": "",
  "Properties": "",
  "MetadataProperties": {
    "CommitId": "",
    "Repository": "",
    "GeneratedBy": "",
    "ProjectId": ""
  },
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ActionName' => '',
  'Source' => '',
  'ActionType' => '',
  'Description' => '',
  'Status' => '',
  'Properties' => '',
  'MetadataProperties' => [
    'CommitId' => '',
    'Repository' => '',
    'GeneratedBy' => '',
    'ProjectId' => ''
  ],
  'Tags' => ''
]));

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

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

append(json_encode([
  'ActionName' => '',
  'Source' => '',
  'ActionType' => '',
  'Description' => '',
  'Status' => '',
  'Properties' => '',
  'MetadataProperties' => [
    'CommitId' => '',
    'Repository' => '',
    'GeneratedBy' => '',
    'ProjectId' => ''
  ],
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAction');
$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=SageMaker.CreateAction' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ActionName": "",
  "Source": "",
  "ActionType": "",
  "Description": "",
  "Status": "",
  "Properties": "",
  "MetadataProperties": {
    "CommitId": "",
    "Repository": "",
    "GeneratedBy": "",
    "ProjectId": ""
  },
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAction' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ActionName": "",
  "Source": "",
  "ActionType": "",
  "Description": "",
  "Status": "",
  "Properties": "",
  "MetadataProperties": {
    "CommitId": "",
    "Repository": "",
    "GeneratedBy": "",
    "ProjectId": ""
  },
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"ActionName\": \"\",\n  \"Source\": \"\",\n  \"ActionType\": \"\",\n  \"Description\": \"\",\n  \"Status\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\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=SageMaker.CreateAction"

payload = {
    "ActionName": "",
    "Source": "",
    "ActionType": "",
    "Description": "",
    "Status": "",
    "Properties": "",
    "MetadataProperties": {
        "CommitId": "",
        "Repository": "",
        "GeneratedBy": "",
        "ProjectId": ""
    },
    "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=SageMaker.CreateAction"

payload <- "{\n  \"ActionName\": \"\",\n  \"Source\": \"\",\n  \"ActionType\": \"\",\n  \"Description\": \"\",\n  \"Status\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\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=SageMaker.CreateAction")

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  \"ActionName\": \"\",\n  \"Source\": \"\",\n  \"ActionType\": \"\",\n  \"Description\": \"\",\n  \"Status\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\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  \"ActionName\": \"\",\n  \"Source\": \"\",\n  \"ActionType\": \"\",\n  \"Description\": \"\",\n  \"Status\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\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=SageMaker.CreateAction";

    let payload = json!({
        "ActionName": "",
        "Source": "",
        "ActionType": "",
        "Description": "",
        "Status": "",
        "Properties": "",
        "MetadataProperties": json!({
            "CommitId": "",
            "Repository": "",
            "GeneratedBy": "",
            "ProjectId": ""
        }),
        "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);
}

echo '{
  "ActionName": "",
  "Source": "",
  "ActionType": "",
  "Description": "",
  "Status": "",
  "Properties": "",
  "MetadataProperties": {
    "CommitId": "",
    "Repository": "",
    "GeneratedBy": "",
    "ProjectId": ""
  },
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAction' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ActionName": "",\n  "Source": "",\n  "ActionType": "",\n  "Description": "",\n  "Status": "",\n  "Properties": "",\n  "MetadataProperties": {\n    "CommitId": "",\n    "Repository": "",\n    "GeneratedBy": "",\n    "ProjectId": ""\n  },\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAction'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ActionName": "",
  "Source": "",
  "ActionType": "",
  "Description": "",
  "Status": "",
  "Properties": "",
  "MetadataProperties": [
    "CommitId": "",
    "Repository": "",
    "GeneratedBy": "",
    "ProjectId": ""
  ],
  "Tags": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

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

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  \"AlgorithmName\": \"\",\n  \"AlgorithmDescription\": \"\",\n  \"TrainingSpecification\": \"\",\n  \"InferenceSpecification\": \"\",\n  \"ValidationSpecification\": \"\",\n  \"CertifyForMarketplace\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAlgorithm" {:headers {:x-amz-target ""}
                                                                                    :content-type :json
                                                                                    :form-params {:AlgorithmName ""
                                                                                                  :AlgorithmDescription ""
                                                                                                  :TrainingSpecification ""
                                                                                                  :InferenceSpecification ""
                                                                                                  :ValidationSpecification ""
                                                                                                  :CertifyForMarketplace ""
                                                                                                  :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAlgorithm"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AlgorithmName\": \"\",\n  \"AlgorithmDescription\": \"\",\n  \"TrainingSpecification\": \"\",\n  \"InferenceSpecification\": \"\",\n  \"ValidationSpecification\": \"\",\n  \"CertifyForMarketplace\": \"\",\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=SageMaker.CreateAlgorithm"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AlgorithmName\": \"\",\n  \"AlgorithmDescription\": \"\",\n  \"TrainingSpecification\": \"\",\n  \"InferenceSpecification\": \"\",\n  \"ValidationSpecification\": \"\",\n  \"CertifyForMarketplace\": \"\",\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=SageMaker.CreateAlgorithm");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AlgorithmName\": \"\",\n  \"AlgorithmDescription\": \"\",\n  \"TrainingSpecification\": \"\",\n  \"InferenceSpecification\": \"\",\n  \"ValidationSpecification\": \"\",\n  \"CertifyForMarketplace\": \"\",\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=SageMaker.CreateAlgorithm"

	payload := strings.NewReader("{\n  \"AlgorithmName\": \"\",\n  \"AlgorithmDescription\": \"\",\n  \"TrainingSpecification\": \"\",\n  \"InferenceSpecification\": \"\",\n  \"ValidationSpecification\": \"\",\n  \"CertifyForMarketplace\": \"\",\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: 196

{
  "AlgorithmName": "",
  "AlgorithmDescription": "",
  "TrainingSpecification": "",
  "InferenceSpecification": "",
  "ValidationSpecification": "",
  "CertifyForMarketplace": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAlgorithm")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AlgorithmName\": \"\",\n  \"AlgorithmDescription\": \"\",\n  \"TrainingSpecification\": \"\",\n  \"InferenceSpecification\": \"\",\n  \"ValidationSpecification\": \"\",\n  \"CertifyForMarketplace\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

const data = JSON.stringify({
  AlgorithmName: '',
  AlgorithmDescription: '',
  TrainingSpecification: '',
  InferenceSpecification: '',
  ValidationSpecification: '',
  CertifyForMarketplace: '',
  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=SageMaker.CreateAlgorithm');
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=SageMaker.CreateAlgorithm',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AlgorithmName: '',
    AlgorithmDescription: '',
    TrainingSpecification: '',
    InferenceSpecification: '',
    ValidationSpecification: '',
    CertifyForMarketplace: '',
    Tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAlgorithm';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AlgorithmName":"","AlgorithmDescription":"","TrainingSpecification":"","InferenceSpecification":"","ValidationSpecification":"","CertifyForMarketplace":"","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=SageMaker.CreateAlgorithm',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AlgorithmName": "",\n  "AlgorithmDescription": "",\n  "TrainingSpecification": "",\n  "InferenceSpecification": "",\n  "ValidationSpecification": "",\n  "CertifyForMarketplace": "",\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  \"AlgorithmName\": \"\",\n  \"AlgorithmDescription\": \"\",\n  \"TrainingSpecification\": \"\",\n  \"InferenceSpecification\": \"\",\n  \"ValidationSpecification\": \"\",\n  \"CertifyForMarketplace\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAlgorithm")
  .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({
  AlgorithmName: '',
  AlgorithmDescription: '',
  TrainingSpecification: '',
  InferenceSpecification: '',
  ValidationSpecification: '',
  CertifyForMarketplace: '',
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAlgorithm',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AlgorithmName: '',
    AlgorithmDescription: '',
    TrainingSpecification: '',
    InferenceSpecification: '',
    ValidationSpecification: '',
    CertifyForMarketplace: '',
    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=SageMaker.CreateAlgorithm');

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

req.type('json');
req.send({
  AlgorithmName: '',
  AlgorithmDescription: '',
  TrainingSpecification: '',
  InferenceSpecification: '',
  ValidationSpecification: '',
  CertifyForMarketplace: '',
  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=SageMaker.CreateAlgorithm',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AlgorithmName: '',
    AlgorithmDescription: '',
    TrainingSpecification: '',
    InferenceSpecification: '',
    ValidationSpecification: '',
    CertifyForMarketplace: '',
    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=SageMaker.CreateAlgorithm';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AlgorithmName":"","AlgorithmDescription":"","TrainingSpecification":"","InferenceSpecification":"","ValidationSpecification":"","CertifyForMarketplace":"","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 = @{ @"AlgorithmName": @"",
                              @"AlgorithmDescription": @"",
                              @"TrainingSpecification": @"",
                              @"InferenceSpecification": @"",
                              @"ValidationSpecification": @"",
                              @"CertifyForMarketplace": @"",
                              @"Tags": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAlgorithm",
  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([
    'AlgorithmName' => '',
    'AlgorithmDescription' => '',
    'TrainingSpecification' => '',
    'InferenceSpecification' => '',
    'ValidationSpecification' => '',
    'CertifyForMarketplace' => '',
    '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=SageMaker.CreateAlgorithm', [
  'body' => '{
  "AlgorithmName": "",
  "AlgorithmDescription": "",
  "TrainingSpecification": "",
  "InferenceSpecification": "",
  "ValidationSpecification": "",
  "CertifyForMarketplace": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AlgorithmName' => '',
  'AlgorithmDescription' => '',
  'TrainingSpecification' => '',
  'InferenceSpecification' => '',
  'ValidationSpecification' => '',
  'CertifyForMarketplace' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'AlgorithmName' => '',
  'AlgorithmDescription' => '',
  'TrainingSpecification' => '',
  'InferenceSpecification' => '',
  'ValidationSpecification' => '',
  'CertifyForMarketplace' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAlgorithm');
$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=SageMaker.CreateAlgorithm' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AlgorithmName": "",
  "AlgorithmDescription": "",
  "TrainingSpecification": "",
  "InferenceSpecification": "",
  "ValidationSpecification": "",
  "CertifyForMarketplace": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAlgorithm' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AlgorithmName": "",
  "AlgorithmDescription": "",
  "TrainingSpecification": "",
  "InferenceSpecification": "",
  "ValidationSpecification": "",
  "CertifyForMarketplace": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"AlgorithmName\": \"\",\n  \"AlgorithmDescription\": \"\",\n  \"TrainingSpecification\": \"\",\n  \"InferenceSpecification\": \"\",\n  \"ValidationSpecification\": \"\",\n  \"CertifyForMarketplace\": \"\",\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=SageMaker.CreateAlgorithm"

payload = {
    "AlgorithmName": "",
    "AlgorithmDescription": "",
    "TrainingSpecification": "",
    "InferenceSpecification": "",
    "ValidationSpecification": "",
    "CertifyForMarketplace": "",
    "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=SageMaker.CreateAlgorithm"

payload <- "{\n  \"AlgorithmName\": \"\",\n  \"AlgorithmDescription\": \"\",\n  \"TrainingSpecification\": \"\",\n  \"InferenceSpecification\": \"\",\n  \"ValidationSpecification\": \"\",\n  \"CertifyForMarketplace\": \"\",\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=SageMaker.CreateAlgorithm")

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  \"AlgorithmName\": \"\",\n  \"AlgorithmDescription\": \"\",\n  \"TrainingSpecification\": \"\",\n  \"InferenceSpecification\": \"\",\n  \"ValidationSpecification\": \"\",\n  \"CertifyForMarketplace\": \"\",\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  \"AlgorithmName\": \"\",\n  \"AlgorithmDescription\": \"\",\n  \"TrainingSpecification\": \"\",\n  \"InferenceSpecification\": \"\",\n  \"ValidationSpecification\": \"\",\n  \"CertifyForMarketplace\": \"\",\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=SageMaker.CreateAlgorithm";

    let payload = json!({
        "AlgorithmName": "",
        "AlgorithmDescription": "",
        "TrainingSpecification": "",
        "InferenceSpecification": "",
        "ValidationSpecification": "",
        "CertifyForMarketplace": "",
        "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);
}

echo '{
  "AlgorithmName": "",
  "AlgorithmDescription": "",
  "TrainingSpecification": "",
  "InferenceSpecification": "",
  "ValidationSpecification": "",
  "CertifyForMarketplace": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAlgorithm' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AlgorithmName": "",\n  "AlgorithmDescription": "",\n  "TrainingSpecification": "",\n  "InferenceSpecification": "",\n  "ValidationSpecification": "",\n  "CertifyForMarketplace": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAlgorithm'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AlgorithmName": "",
  "AlgorithmDescription": "",
  "TrainingSpecification": "",
  "InferenceSpecification": "",
  "ValidationSpecification": "",
  "CertifyForMarketplace": "",
  "Tags": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

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

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  \"DomainId\": \"\",\n  \"UserProfileName\": \"\",\n  \"AppType\": \"\",\n  \"AppName\": \"\",\n  \"Tags\": \"\",\n  \"ResourceSpec\": \"\",\n  \"SpaceName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateApp" {:headers {:x-amz-target ""}
                                                                              :content-type :json
                                                                              :form-params {:DomainId ""
                                                                                            :UserProfileName ""
                                                                                            :AppType ""
                                                                                            :AppName ""
                                                                                            :Tags ""
                                                                                            :ResourceSpec ""
                                                                                            :SpaceName ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateApp"

	payload := strings.NewReader("{\n  \"DomainId\": \"\",\n  \"UserProfileName\": \"\",\n  \"AppType\": \"\",\n  \"AppName\": \"\",\n  \"Tags\": \"\",\n  \"ResourceSpec\": \"\",\n  \"SpaceName\": \"\"\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: 134

{
  "DomainId": "",
  "UserProfileName": "",
  "AppType": "",
  "AppName": "",
  "Tags": "",
  "ResourceSpec": "",
  "SpaceName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateApp")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DomainId\": \"\",\n  \"UserProfileName\": \"\",\n  \"AppType\": \"\",\n  \"AppName\": \"\",\n  \"Tags\": \"\",\n  \"ResourceSpec\": \"\",\n  \"SpaceName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

const data = JSON.stringify({
  DomainId: '',
  UserProfileName: '',
  AppType: '',
  AppName: '',
  Tags: '',
  ResourceSpec: '',
  SpaceName: ''
});

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=SageMaker.CreateApp');
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=SageMaker.CreateApp',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    DomainId: '',
    UserProfileName: '',
    AppType: '',
    AppName: '',
    Tags: '',
    ResourceSpec: '',
    SpaceName: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateApp';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DomainId":"","UserProfileName":"","AppType":"","AppName":"","Tags":"","ResourceSpec":"","SpaceName":""}'
};

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=SageMaker.CreateApp',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DomainId": "",\n  "UserProfileName": "",\n  "AppType": "",\n  "AppName": "",\n  "Tags": "",\n  "ResourceSpec": "",\n  "SpaceName": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DomainId\": \"\",\n  \"UserProfileName\": \"\",\n  \"AppType\": \"\",\n  \"AppName\": \"\",\n  \"Tags\": \"\",\n  \"ResourceSpec\": \"\",\n  \"SpaceName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateApp")
  .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({
  DomainId: '',
  UserProfileName: '',
  AppType: '',
  AppName: '',
  Tags: '',
  ResourceSpec: '',
  SpaceName: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateApp',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    DomainId: '',
    UserProfileName: '',
    AppType: '',
    AppName: '',
    Tags: '',
    ResourceSpec: '',
    SpaceName: ''
  },
  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=SageMaker.CreateApp');

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

req.type('json');
req.send({
  DomainId: '',
  UserProfileName: '',
  AppType: '',
  AppName: '',
  Tags: '',
  ResourceSpec: '',
  SpaceName: ''
});

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=SageMaker.CreateApp',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    DomainId: '',
    UserProfileName: '',
    AppType: '',
    AppName: '',
    Tags: '',
    ResourceSpec: '',
    SpaceName: ''
  }
};

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=SageMaker.CreateApp';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DomainId":"","UserProfileName":"","AppType":"","AppName":"","Tags":"","ResourceSpec":"","SpaceName":""}'
};

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 = @{ @"DomainId": @"",
                              @"UserProfileName": @"",
                              @"AppType": @"",
                              @"AppName": @"",
                              @"Tags": @"",
                              @"ResourceSpec": @"",
                              @"SpaceName": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateApp",
  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([
    'DomainId' => '',
    'UserProfileName' => '',
    'AppType' => '',
    'AppName' => '',
    'Tags' => '',
    'ResourceSpec' => '',
    'SpaceName' => ''
  ]),
  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=SageMaker.CreateApp', [
  'body' => '{
  "DomainId": "",
  "UserProfileName": "",
  "AppType": "",
  "AppName": "",
  "Tags": "",
  "ResourceSpec": "",
  "SpaceName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DomainId' => '',
  'UserProfileName' => '',
  'AppType' => '',
  'AppName' => '',
  'Tags' => '',
  'ResourceSpec' => '',
  'SpaceName' => ''
]));

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

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

append(json_encode([
  'DomainId' => '',
  'UserProfileName' => '',
  'AppType' => '',
  'AppName' => '',
  'Tags' => '',
  'ResourceSpec' => '',
  'SpaceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateApp');
$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=SageMaker.CreateApp' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DomainId": "",
  "UserProfileName": "",
  "AppType": "",
  "AppName": "",
  "Tags": "",
  "ResourceSpec": "",
  "SpaceName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateApp' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DomainId": "",
  "UserProfileName": "",
  "AppType": "",
  "AppName": "",
  "Tags": "",
  "ResourceSpec": "",
  "SpaceName": ""
}'

import http.client

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

payload = "{\n  \"DomainId\": \"\",\n  \"UserProfileName\": \"\",\n  \"AppType\": \"\",\n  \"AppName\": \"\",\n  \"Tags\": \"\",\n  \"ResourceSpec\": \"\",\n  \"SpaceName\": \"\"\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=SageMaker.CreateApp"

payload = {
    "DomainId": "",
    "UserProfileName": "",
    "AppType": "",
    "AppName": "",
    "Tags": "",
    "ResourceSpec": "",
    "SpaceName": ""
}
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=SageMaker.CreateApp"

payload <- "{\n  \"DomainId\": \"\",\n  \"UserProfileName\": \"\",\n  \"AppType\": \"\",\n  \"AppName\": \"\",\n  \"Tags\": \"\",\n  \"ResourceSpec\": \"\",\n  \"SpaceName\": \"\"\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=SageMaker.CreateApp")

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  \"DomainId\": \"\",\n  \"UserProfileName\": \"\",\n  \"AppType\": \"\",\n  \"AppName\": \"\",\n  \"Tags\": \"\",\n  \"ResourceSpec\": \"\",\n  \"SpaceName\": \"\"\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  \"DomainId\": \"\",\n  \"UserProfileName\": \"\",\n  \"AppType\": \"\",\n  \"AppName\": \"\",\n  \"Tags\": \"\",\n  \"ResourceSpec\": \"\",\n  \"SpaceName\": \"\"\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=SageMaker.CreateApp";

    let payload = json!({
        "DomainId": "",
        "UserProfileName": "",
        "AppType": "",
        "AppName": "",
        "Tags": "",
        "ResourceSpec": "",
        "SpaceName": ""
    });

    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);
}

echo '{
  "DomainId": "",
  "UserProfileName": "",
  "AppType": "",
  "AppName": "",
  "Tags": "",
  "ResourceSpec": "",
  "SpaceName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateApp' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "DomainId": "",\n  "UserProfileName": "",\n  "AppType": "",\n  "AppName": "",\n  "Tags": "",\n  "ResourceSpec": "",\n  "SpaceName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateApp'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "DomainId": "",
  "UserProfileName": "",
  "AppType": "",
  "AppName": "",
  "Tags": "",
  "ResourceSpec": "",
  "SpaceName": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

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

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  \"AppImageConfigName\": \"\",\n  \"Tags\": \"\",\n  \"KernelGatewayImageConfig\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAppImageConfig" {:headers {:x-amz-target ""}
                                                                                         :content-type :json
                                                                                         :form-params {:AppImageConfigName ""
                                                                                                       :Tags ""
                                                                                                       :KernelGatewayImageConfig ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAppImageConfig"

	payload := strings.NewReader("{\n  \"AppImageConfigName\": \"\",\n  \"Tags\": \"\",\n  \"KernelGatewayImageConfig\": \"\"\n}")

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

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

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

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

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

}

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

{
  "AppImageConfigName": "",
  "Tags": "",
  "KernelGatewayImageConfig": ""
}

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

client.close();

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

const data = JSON.stringify({
  AppImageConfigName: '',
  Tags: '',
  KernelGatewayImageConfig: ''
});

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=SageMaker.CreateAppImageConfig');
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=SageMaker.CreateAppImageConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AppImageConfigName: '', Tags: '', KernelGatewayImageConfig: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAppImageConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AppImageConfigName":"","Tags":"","KernelGatewayImageConfig":""}'
};

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  AppImageConfigName: '',
  Tags: '',
  KernelGatewayImageConfig: ''
});

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=SageMaker.CreateAppImageConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AppImageConfigName: '', Tags: '', KernelGatewayImageConfig: ''}
};

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=SageMaker.CreateAppImageConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AppImageConfigName":"","Tags":"","KernelGatewayImageConfig":""}'
};

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 = @{ @"AppImageConfigName": @"",
                              @"Tags": @"",
                              @"KernelGatewayImageConfig": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AppImageConfigName' => '',
  'Tags' => '',
  'KernelGatewayImageConfig' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"AppImageConfigName\": \"\",\n  \"Tags\": \"\",\n  \"KernelGatewayImageConfig\": \"\"\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=SageMaker.CreateAppImageConfig"

payload = {
    "AppImageConfigName": "",
    "Tags": "",
    "KernelGatewayImageConfig": ""
}
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=SageMaker.CreateAppImageConfig"

payload <- "{\n  \"AppImageConfigName\": \"\",\n  \"Tags\": \"\",\n  \"KernelGatewayImageConfig\": \"\"\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=SageMaker.CreateAppImageConfig")

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  \"AppImageConfigName\": \"\",\n  \"Tags\": \"\",\n  \"KernelGatewayImageConfig\": \"\"\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  \"AppImageConfigName\": \"\",\n  \"Tags\": \"\",\n  \"KernelGatewayImageConfig\": \"\"\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=SageMaker.CreateAppImageConfig";

    let payload = json!({
        "AppImageConfigName": "",
        "Tags": "",
        "KernelGatewayImageConfig": ""
    });

    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);
}

echo '{
  "AppImageConfigName": "",
  "Tags": "",
  "KernelGatewayImageConfig": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAppImageConfig' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AppImageConfigName": "",\n  "Tags": "",\n  "KernelGatewayImageConfig": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAppImageConfig'

import Foundation

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

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

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

CURL *hnd = curl_easy_init();

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

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  \"ArtifactName\": \"\",\n  \"Source\": \"\",\n  \"ArtifactType\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateArtifact" {:headers {:x-amz-target ""}
                                                                                   :content-type :json
                                                                                   :form-params {:ArtifactName ""
                                                                                                 :Source ""
                                                                                                 :ArtifactType ""
                                                                                                 :Properties ""
                                                                                                 :MetadataProperties {:CommitId ""
                                                                                                                      :Repository ""
                                                                                                                      :GeneratedBy ""
                                                                                                                      :ProjectId ""}
                                                                                                 :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateArtifact"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ArtifactName\": \"\",\n  \"Source\": \"\",\n  \"ArtifactType\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\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=SageMaker.CreateArtifact"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ArtifactName\": \"\",\n  \"Source\": \"\",\n  \"ArtifactType\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\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=SageMaker.CreateArtifact");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ArtifactName\": \"\",\n  \"Source\": \"\",\n  \"ArtifactType\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\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=SageMaker.CreateArtifact"

	payload := strings.NewReader("{\n  \"ArtifactName\": \"\",\n  \"Source\": \"\",\n  \"ArtifactType\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\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: 212

{
  "ArtifactName": "",
  "Source": "",
  "ArtifactType": "",
  "Properties": "",
  "MetadataProperties": {
    "CommitId": "",
    "Repository": "",
    "GeneratedBy": "",
    "ProjectId": ""
  },
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateArtifact")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ArtifactName\": \"\",\n  \"Source\": \"\",\n  \"ArtifactType\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateArtifact"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ArtifactName\": \"\",\n  \"Source\": \"\",\n  \"ArtifactType\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\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  \"ArtifactName\": \"\",\n  \"Source\": \"\",\n  \"ArtifactType\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateArtifact")
  .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=SageMaker.CreateArtifact")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ArtifactName\": \"\",\n  \"Source\": \"\",\n  \"ArtifactType\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ArtifactName: '',
  Source: '',
  ArtifactType: '',
  Properties: '',
  MetadataProperties: {
    CommitId: '',
    Repository: '',
    GeneratedBy: '',
    ProjectId: ''
  },
  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=SageMaker.CreateArtifact');
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=SageMaker.CreateArtifact',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ArtifactName: '',
    Source: '',
    ArtifactType: '',
    Properties: '',
    MetadataProperties: {CommitId: '', Repository: '', GeneratedBy: '', ProjectId: ''},
    Tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateArtifact';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ArtifactName":"","Source":"","ArtifactType":"","Properties":"","MetadataProperties":{"CommitId":"","Repository":"","GeneratedBy":"","ProjectId":""},"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=SageMaker.CreateArtifact',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ArtifactName": "",\n  "Source": "",\n  "ArtifactType": "",\n  "Properties": "",\n  "MetadataProperties": {\n    "CommitId": "",\n    "Repository": "",\n    "GeneratedBy": "",\n    "ProjectId": ""\n  },\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  \"ArtifactName\": \"\",\n  \"Source\": \"\",\n  \"ArtifactType\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateArtifact")
  .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({
  ArtifactName: '',
  Source: '',
  ArtifactType: '',
  Properties: '',
  MetadataProperties: {CommitId: '', Repository: '', GeneratedBy: '', ProjectId: ''},
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateArtifact',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ArtifactName: '',
    Source: '',
    ArtifactType: '',
    Properties: '',
    MetadataProperties: {CommitId: '', Repository: '', GeneratedBy: '', ProjectId: ''},
    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=SageMaker.CreateArtifact');

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

req.type('json');
req.send({
  ArtifactName: '',
  Source: '',
  ArtifactType: '',
  Properties: '',
  MetadataProperties: {
    CommitId: '',
    Repository: '',
    GeneratedBy: '',
    ProjectId: ''
  },
  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=SageMaker.CreateArtifact',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ArtifactName: '',
    Source: '',
    ArtifactType: '',
    Properties: '',
    MetadataProperties: {CommitId: '', Repository: '', GeneratedBy: '', ProjectId: ''},
    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=SageMaker.CreateArtifact';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ArtifactName":"","Source":"","ArtifactType":"","Properties":"","MetadataProperties":{"CommitId":"","Repository":"","GeneratedBy":"","ProjectId":""},"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 = @{ @"ArtifactName": @"",
                              @"Source": @"",
                              @"ArtifactType": @"",
                              @"Properties": @"",
                              @"MetadataProperties": @{ @"CommitId": @"", @"Repository": @"", @"GeneratedBy": @"", @"ProjectId": @"" },
                              @"Tags": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreateArtifact"]
                                                       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=SageMaker.CreateArtifact" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ArtifactName\": \"\",\n  \"Source\": \"\",\n  \"ArtifactType\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\n  \"Tags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateArtifact",
  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([
    'ArtifactName' => '',
    'Source' => '',
    'ArtifactType' => '',
    'Properties' => '',
    'MetadataProperties' => [
        'CommitId' => '',
        'Repository' => '',
        'GeneratedBy' => '',
        'ProjectId' => ''
    ],
    '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=SageMaker.CreateArtifact', [
  'body' => '{
  "ArtifactName": "",
  "Source": "",
  "ArtifactType": "",
  "Properties": "",
  "MetadataProperties": {
    "CommitId": "",
    "Repository": "",
    "GeneratedBy": "",
    "ProjectId": ""
  },
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ArtifactName' => '',
  'Source' => '',
  'ArtifactType' => '',
  'Properties' => '',
  'MetadataProperties' => [
    'CommitId' => '',
    'Repository' => '',
    'GeneratedBy' => '',
    'ProjectId' => ''
  ],
  'Tags' => ''
]));

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

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

append(json_encode([
  'ArtifactName' => '',
  'Source' => '',
  'ArtifactType' => '',
  'Properties' => '',
  'MetadataProperties' => [
    'CommitId' => '',
    'Repository' => '',
    'GeneratedBy' => '',
    'ProjectId' => ''
  ],
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateArtifact');
$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=SageMaker.CreateArtifact' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ArtifactName": "",
  "Source": "",
  "ArtifactType": "",
  "Properties": "",
  "MetadataProperties": {
    "CommitId": "",
    "Repository": "",
    "GeneratedBy": "",
    "ProjectId": ""
  },
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateArtifact' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ArtifactName": "",
  "Source": "",
  "ArtifactType": "",
  "Properties": "",
  "MetadataProperties": {
    "CommitId": "",
    "Repository": "",
    "GeneratedBy": "",
    "ProjectId": ""
  },
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"ArtifactName\": \"\",\n  \"Source\": \"\",\n  \"ArtifactType\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\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=SageMaker.CreateArtifact"

payload = {
    "ArtifactName": "",
    "Source": "",
    "ArtifactType": "",
    "Properties": "",
    "MetadataProperties": {
        "CommitId": "",
        "Repository": "",
        "GeneratedBy": "",
        "ProjectId": ""
    },
    "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=SageMaker.CreateArtifact"

payload <- "{\n  \"ArtifactName\": \"\",\n  \"Source\": \"\",\n  \"ArtifactType\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\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=SageMaker.CreateArtifact")

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  \"ArtifactName\": \"\",\n  \"Source\": \"\",\n  \"ArtifactType\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\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  \"ArtifactName\": \"\",\n  \"Source\": \"\",\n  \"ArtifactType\": \"\",\n  \"Properties\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\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=SageMaker.CreateArtifact";

    let payload = json!({
        "ArtifactName": "",
        "Source": "",
        "ArtifactType": "",
        "Properties": "",
        "MetadataProperties": json!({
            "CommitId": "",
            "Repository": "",
            "GeneratedBy": "",
            "ProjectId": ""
        }),
        "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);
}

echo '{
  "ArtifactName": "",
  "Source": "",
  "ArtifactType": "",
  "Properties": "",
  "MetadataProperties": {
    "CommitId": "",
    "Repository": "",
    "GeneratedBy": "",
    "ProjectId": ""
  },
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateArtifact' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ArtifactName": "",\n  "Source": "",\n  "ArtifactType": "",\n  "Properties": "",\n  "MetadataProperties": {\n    "CommitId": "",\n    "Repository": "",\n    "GeneratedBy": "",\n    "ProjectId": ""\n  },\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateArtifact'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ArtifactName": "",
  "Source": "",
  "ArtifactType": "",
  "Properties": "",
  "MetadataProperties": [
    "CommitId": "",
    "Repository": "",
    "GeneratedBy": "",
    "ProjectId": ""
  ],
  "Tags": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

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

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  \"AutoMLJobName\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ProblemType\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"AutoMLJobConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"GenerateCandidateDefinitionsOnly\": \"\",\n  \"Tags\": \"\",\n  \"ModelDeployConfig\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJob" {:headers {:x-amz-target ""}
                                                                                    :content-type :json
                                                                                    :form-params {:AutoMLJobName ""
                                                                                                  :InputDataConfig ""
                                                                                                  :OutputDataConfig ""
                                                                                                  :ProblemType ""
                                                                                                  :AutoMLJobObjective ""
                                                                                                  :AutoMLJobConfig ""
                                                                                                  :RoleArn ""
                                                                                                  :GenerateCandidateDefinitionsOnly ""
                                                                                                  :Tags ""
                                                                                                  :ModelDeployConfig ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJob"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AutoMLJobName\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ProblemType\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"AutoMLJobConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"GenerateCandidateDefinitionsOnly\": \"\",\n  \"Tags\": \"\",\n  \"ModelDeployConfig\": \"\"\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=SageMaker.CreateAutoMLJob"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AutoMLJobName\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ProblemType\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"AutoMLJobConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"GenerateCandidateDefinitionsOnly\": \"\",\n  \"Tags\": \"\",\n  \"ModelDeployConfig\": \"\"\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=SageMaker.CreateAutoMLJob");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AutoMLJobName\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ProblemType\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"AutoMLJobConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"GenerateCandidateDefinitionsOnly\": \"\",\n  \"Tags\": \"\",\n  \"ModelDeployConfig\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJob"

	payload := strings.NewReader("{\n  \"AutoMLJobName\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ProblemType\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"AutoMLJobConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"GenerateCandidateDefinitionsOnly\": \"\",\n  \"Tags\": \"\",\n  \"ModelDeployConfig\": \"\"\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: 250

{
  "AutoMLJobName": "",
  "InputDataConfig": "",
  "OutputDataConfig": "",
  "ProblemType": "",
  "AutoMLJobObjective": "",
  "AutoMLJobConfig": "",
  "RoleArn": "",
  "GenerateCandidateDefinitionsOnly": "",
  "Tags": "",
  "ModelDeployConfig": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJob")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AutoMLJobName\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ProblemType\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"AutoMLJobConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"GenerateCandidateDefinitionsOnly\": \"\",\n  \"Tags\": \"\",\n  \"ModelDeployConfig\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJob"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AutoMLJobName\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ProblemType\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"AutoMLJobConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"GenerateCandidateDefinitionsOnly\": \"\",\n  \"Tags\": \"\",\n  \"ModelDeployConfig\": \"\"\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  \"AutoMLJobName\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ProblemType\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"AutoMLJobConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"GenerateCandidateDefinitionsOnly\": \"\",\n  \"Tags\": \"\",\n  \"ModelDeployConfig\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJob")
  .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=SageMaker.CreateAutoMLJob")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AutoMLJobName\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ProblemType\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"AutoMLJobConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"GenerateCandidateDefinitionsOnly\": \"\",\n  \"Tags\": \"\",\n  \"ModelDeployConfig\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AutoMLJobName: '',
  InputDataConfig: '',
  OutputDataConfig: '',
  ProblemType: '',
  AutoMLJobObjective: '',
  AutoMLJobConfig: '',
  RoleArn: '',
  GenerateCandidateDefinitionsOnly: '',
  Tags: '',
  ModelDeployConfig: ''
});

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=SageMaker.CreateAutoMLJob');
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=SageMaker.CreateAutoMLJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AutoMLJobName: '',
    InputDataConfig: '',
    OutputDataConfig: '',
    ProblemType: '',
    AutoMLJobObjective: '',
    AutoMLJobConfig: '',
    RoleArn: '',
    GenerateCandidateDefinitionsOnly: '',
    Tags: '',
    ModelDeployConfig: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AutoMLJobName":"","InputDataConfig":"","OutputDataConfig":"","ProblemType":"","AutoMLJobObjective":"","AutoMLJobConfig":"","RoleArn":"","GenerateCandidateDefinitionsOnly":"","Tags":"","ModelDeployConfig":""}'
};

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=SageMaker.CreateAutoMLJob',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AutoMLJobName": "",\n  "InputDataConfig": "",\n  "OutputDataConfig": "",\n  "ProblemType": "",\n  "AutoMLJobObjective": "",\n  "AutoMLJobConfig": "",\n  "RoleArn": "",\n  "GenerateCandidateDefinitionsOnly": "",\n  "Tags": "",\n  "ModelDeployConfig": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AutoMLJobName\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ProblemType\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"AutoMLJobConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"GenerateCandidateDefinitionsOnly\": \"\",\n  \"Tags\": \"\",\n  \"ModelDeployConfig\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJob")
  .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({
  AutoMLJobName: '',
  InputDataConfig: '',
  OutputDataConfig: '',
  ProblemType: '',
  AutoMLJobObjective: '',
  AutoMLJobConfig: '',
  RoleArn: '',
  GenerateCandidateDefinitionsOnly: '',
  Tags: '',
  ModelDeployConfig: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AutoMLJobName: '',
    InputDataConfig: '',
    OutputDataConfig: '',
    ProblemType: '',
    AutoMLJobObjective: '',
    AutoMLJobConfig: '',
    RoleArn: '',
    GenerateCandidateDefinitionsOnly: '',
    Tags: '',
    ModelDeployConfig: ''
  },
  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=SageMaker.CreateAutoMLJob');

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

req.type('json');
req.send({
  AutoMLJobName: '',
  InputDataConfig: '',
  OutputDataConfig: '',
  ProblemType: '',
  AutoMLJobObjective: '',
  AutoMLJobConfig: '',
  RoleArn: '',
  GenerateCandidateDefinitionsOnly: '',
  Tags: '',
  ModelDeployConfig: ''
});

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=SageMaker.CreateAutoMLJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AutoMLJobName: '',
    InputDataConfig: '',
    OutputDataConfig: '',
    ProblemType: '',
    AutoMLJobObjective: '',
    AutoMLJobConfig: '',
    RoleArn: '',
    GenerateCandidateDefinitionsOnly: '',
    Tags: '',
    ModelDeployConfig: ''
  }
};

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=SageMaker.CreateAutoMLJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AutoMLJobName":"","InputDataConfig":"","OutputDataConfig":"","ProblemType":"","AutoMLJobObjective":"","AutoMLJobConfig":"","RoleArn":"","GenerateCandidateDefinitionsOnly":"","Tags":"","ModelDeployConfig":""}'
};

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 = @{ @"AutoMLJobName": @"",
                              @"InputDataConfig": @"",
                              @"OutputDataConfig": @"",
                              @"ProblemType": @"",
                              @"AutoMLJobObjective": @"",
                              @"AutoMLJobConfig": @"",
                              @"RoleArn": @"",
                              @"GenerateCandidateDefinitionsOnly": @"",
                              @"Tags": @"",
                              @"ModelDeployConfig": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJob"]
                                                       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=SageMaker.CreateAutoMLJob" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AutoMLJobName\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ProblemType\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"AutoMLJobConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"GenerateCandidateDefinitionsOnly\": \"\",\n  \"Tags\": \"\",\n  \"ModelDeployConfig\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJob",
  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([
    'AutoMLJobName' => '',
    'InputDataConfig' => '',
    'OutputDataConfig' => '',
    'ProblemType' => '',
    'AutoMLJobObjective' => '',
    'AutoMLJobConfig' => '',
    'RoleArn' => '',
    'GenerateCandidateDefinitionsOnly' => '',
    'Tags' => '',
    'ModelDeployConfig' => ''
  ]),
  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=SageMaker.CreateAutoMLJob', [
  'body' => '{
  "AutoMLJobName": "",
  "InputDataConfig": "",
  "OutputDataConfig": "",
  "ProblemType": "",
  "AutoMLJobObjective": "",
  "AutoMLJobConfig": "",
  "RoleArn": "",
  "GenerateCandidateDefinitionsOnly": "",
  "Tags": "",
  "ModelDeployConfig": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AutoMLJobName' => '',
  'InputDataConfig' => '',
  'OutputDataConfig' => '',
  'ProblemType' => '',
  'AutoMLJobObjective' => '',
  'AutoMLJobConfig' => '',
  'RoleArn' => '',
  'GenerateCandidateDefinitionsOnly' => '',
  'Tags' => '',
  'ModelDeployConfig' => ''
]));

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

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

append(json_encode([
  'AutoMLJobName' => '',
  'InputDataConfig' => '',
  'OutputDataConfig' => '',
  'ProblemType' => '',
  'AutoMLJobObjective' => '',
  'AutoMLJobConfig' => '',
  'RoleArn' => '',
  'GenerateCandidateDefinitionsOnly' => '',
  'Tags' => '',
  'ModelDeployConfig' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJob');
$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=SageMaker.CreateAutoMLJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AutoMLJobName": "",
  "InputDataConfig": "",
  "OutputDataConfig": "",
  "ProblemType": "",
  "AutoMLJobObjective": "",
  "AutoMLJobConfig": "",
  "RoleArn": "",
  "GenerateCandidateDefinitionsOnly": "",
  "Tags": "",
  "ModelDeployConfig": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AutoMLJobName": "",
  "InputDataConfig": "",
  "OutputDataConfig": "",
  "ProblemType": "",
  "AutoMLJobObjective": "",
  "AutoMLJobConfig": "",
  "RoleArn": "",
  "GenerateCandidateDefinitionsOnly": "",
  "Tags": "",
  "ModelDeployConfig": ""
}'

import http.client

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

payload = "{\n  \"AutoMLJobName\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ProblemType\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"AutoMLJobConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"GenerateCandidateDefinitionsOnly\": \"\",\n  \"Tags\": \"\",\n  \"ModelDeployConfig\": \"\"\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=SageMaker.CreateAutoMLJob"

payload = {
    "AutoMLJobName": "",
    "InputDataConfig": "",
    "OutputDataConfig": "",
    "ProblemType": "",
    "AutoMLJobObjective": "",
    "AutoMLJobConfig": "",
    "RoleArn": "",
    "GenerateCandidateDefinitionsOnly": "",
    "Tags": "",
    "ModelDeployConfig": ""
}
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=SageMaker.CreateAutoMLJob"

payload <- "{\n  \"AutoMLJobName\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ProblemType\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"AutoMLJobConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"GenerateCandidateDefinitionsOnly\": \"\",\n  \"Tags\": \"\",\n  \"ModelDeployConfig\": \"\"\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=SageMaker.CreateAutoMLJob")

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  \"AutoMLJobName\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ProblemType\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"AutoMLJobConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"GenerateCandidateDefinitionsOnly\": \"\",\n  \"Tags\": \"\",\n  \"ModelDeployConfig\": \"\"\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  \"AutoMLJobName\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ProblemType\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"AutoMLJobConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"GenerateCandidateDefinitionsOnly\": \"\",\n  \"Tags\": \"\",\n  \"ModelDeployConfig\": \"\"\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=SageMaker.CreateAutoMLJob";

    let payload = json!({
        "AutoMLJobName": "",
        "InputDataConfig": "",
        "OutputDataConfig": "",
        "ProblemType": "",
        "AutoMLJobObjective": "",
        "AutoMLJobConfig": "",
        "RoleArn": "",
        "GenerateCandidateDefinitionsOnly": "",
        "Tags": "",
        "ModelDeployConfig": ""
    });

    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);
}

echo '{
  "AutoMLJobName": "",
  "InputDataConfig": "",
  "OutputDataConfig": "",
  "ProblemType": "",
  "AutoMLJobObjective": "",
  "AutoMLJobConfig": "",
  "RoleArn": "",
  "GenerateCandidateDefinitionsOnly": "",
  "Tags": "",
  "ModelDeployConfig": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJob' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AutoMLJobName": "",\n  "InputDataConfig": "",\n  "OutputDataConfig": "",\n  "ProblemType": "",\n  "AutoMLJobObjective": "",\n  "AutoMLJobConfig": "",\n  "RoleArn": "",\n  "GenerateCandidateDefinitionsOnly": "",\n  "Tags": "",\n  "ModelDeployConfig": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJob'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AutoMLJobName": "",
  "InputDataConfig": "",
  "OutputDataConfig": "",
  "ProblemType": "",
  "AutoMLJobObjective": "",
  "AutoMLJobConfig": "",
  "RoleArn": "",
  "GenerateCandidateDefinitionsOnly": "",
  "Tags": "",
  "ModelDeployConfig": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

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

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  \"AutoMLJobName\": \"\",\n  \"AutoMLJobInputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"AutoMLProblemTypeConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"SecurityConfig\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"ModelDeployConfig\": \"\",\n  \"DataSplitConfig\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJobV2" {:headers {:x-amz-target ""}
                                                                                      :content-type :json
                                                                                      :form-params {:AutoMLJobName ""
                                                                                                    :AutoMLJobInputDataConfig ""
                                                                                                    :OutputDataConfig ""
                                                                                                    :AutoMLProblemTypeConfig ""
                                                                                                    :RoleArn ""
                                                                                                    :Tags ""
                                                                                                    :SecurityConfig ""
                                                                                                    :AutoMLJobObjective ""
                                                                                                    :ModelDeployConfig ""
                                                                                                    :DataSplitConfig ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJobV2"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AutoMLJobName\": \"\",\n  \"AutoMLJobInputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"AutoMLProblemTypeConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"SecurityConfig\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"ModelDeployConfig\": \"\",\n  \"DataSplitConfig\": \"\"\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=SageMaker.CreateAutoMLJobV2"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AutoMLJobName\": \"\",\n  \"AutoMLJobInputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"AutoMLProblemTypeConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"SecurityConfig\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"ModelDeployConfig\": \"\",\n  \"DataSplitConfig\": \"\"\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=SageMaker.CreateAutoMLJobV2");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AutoMLJobName\": \"\",\n  \"AutoMLJobInputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"AutoMLProblemTypeConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"SecurityConfig\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"ModelDeployConfig\": \"\",\n  \"DataSplitConfig\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJobV2"

	payload := strings.NewReader("{\n  \"AutoMLJobName\": \"\",\n  \"AutoMLJobInputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"AutoMLProblemTypeConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"SecurityConfig\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"ModelDeployConfig\": \"\",\n  \"DataSplitConfig\": \"\"\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: 253

{
  "AutoMLJobName": "",
  "AutoMLJobInputDataConfig": "",
  "OutputDataConfig": "",
  "AutoMLProblemTypeConfig": "",
  "RoleArn": "",
  "Tags": "",
  "SecurityConfig": "",
  "AutoMLJobObjective": "",
  "ModelDeployConfig": "",
  "DataSplitConfig": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJobV2")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AutoMLJobName\": \"\",\n  \"AutoMLJobInputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"AutoMLProblemTypeConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"SecurityConfig\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"ModelDeployConfig\": \"\",\n  \"DataSplitConfig\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJobV2"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AutoMLJobName\": \"\",\n  \"AutoMLJobInputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"AutoMLProblemTypeConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"SecurityConfig\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"ModelDeployConfig\": \"\",\n  \"DataSplitConfig\": \"\"\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  \"AutoMLJobName\": \"\",\n  \"AutoMLJobInputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"AutoMLProblemTypeConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"SecurityConfig\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"ModelDeployConfig\": \"\",\n  \"DataSplitConfig\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJobV2")
  .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=SageMaker.CreateAutoMLJobV2")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AutoMLJobName\": \"\",\n  \"AutoMLJobInputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"AutoMLProblemTypeConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"SecurityConfig\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"ModelDeployConfig\": \"\",\n  \"DataSplitConfig\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AutoMLJobName: '',
  AutoMLJobInputDataConfig: '',
  OutputDataConfig: '',
  AutoMLProblemTypeConfig: '',
  RoleArn: '',
  Tags: '',
  SecurityConfig: '',
  AutoMLJobObjective: '',
  ModelDeployConfig: '',
  DataSplitConfig: ''
});

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=SageMaker.CreateAutoMLJobV2');
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=SageMaker.CreateAutoMLJobV2',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AutoMLJobName: '',
    AutoMLJobInputDataConfig: '',
    OutputDataConfig: '',
    AutoMLProblemTypeConfig: '',
    RoleArn: '',
    Tags: '',
    SecurityConfig: '',
    AutoMLJobObjective: '',
    ModelDeployConfig: '',
    DataSplitConfig: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJobV2';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AutoMLJobName":"","AutoMLJobInputDataConfig":"","OutputDataConfig":"","AutoMLProblemTypeConfig":"","RoleArn":"","Tags":"","SecurityConfig":"","AutoMLJobObjective":"","ModelDeployConfig":"","DataSplitConfig":""}'
};

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=SageMaker.CreateAutoMLJobV2',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AutoMLJobName": "",\n  "AutoMLJobInputDataConfig": "",\n  "OutputDataConfig": "",\n  "AutoMLProblemTypeConfig": "",\n  "RoleArn": "",\n  "Tags": "",\n  "SecurityConfig": "",\n  "AutoMLJobObjective": "",\n  "ModelDeployConfig": "",\n  "DataSplitConfig": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AutoMLJobName\": \"\",\n  \"AutoMLJobInputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"AutoMLProblemTypeConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"SecurityConfig\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"ModelDeployConfig\": \"\",\n  \"DataSplitConfig\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJobV2")
  .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({
  AutoMLJobName: '',
  AutoMLJobInputDataConfig: '',
  OutputDataConfig: '',
  AutoMLProblemTypeConfig: '',
  RoleArn: '',
  Tags: '',
  SecurityConfig: '',
  AutoMLJobObjective: '',
  ModelDeployConfig: '',
  DataSplitConfig: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJobV2',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AutoMLJobName: '',
    AutoMLJobInputDataConfig: '',
    OutputDataConfig: '',
    AutoMLProblemTypeConfig: '',
    RoleArn: '',
    Tags: '',
    SecurityConfig: '',
    AutoMLJobObjective: '',
    ModelDeployConfig: '',
    DataSplitConfig: ''
  },
  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=SageMaker.CreateAutoMLJobV2');

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

req.type('json');
req.send({
  AutoMLJobName: '',
  AutoMLJobInputDataConfig: '',
  OutputDataConfig: '',
  AutoMLProblemTypeConfig: '',
  RoleArn: '',
  Tags: '',
  SecurityConfig: '',
  AutoMLJobObjective: '',
  ModelDeployConfig: '',
  DataSplitConfig: ''
});

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=SageMaker.CreateAutoMLJobV2',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AutoMLJobName: '',
    AutoMLJobInputDataConfig: '',
    OutputDataConfig: '',
    AutoMLProblemTypeConfig: '',
    RoleArn: '',
    Tags: '',
    SecurityConfig: '',
    AutoMLJobObjective: '',
    ModelDeployConfig: '',
    DataSplitConfig: ''
  }
};

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=SageMaker.CreateAutoMLJobV2';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AutoMLJobName":"","AutoMLJobInputDataConfig":"","OutputDataConfig":"","AutoMLProblemTypeConfig":"","RoleArn":"","Tags":"","SecurityConfig":"","AutoMLJobObjective":"","ModelDeployConfig":"","DataSplitConfig":""}'
};

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 = @{ @"AutoMLJobName": @"",
                              @"AutoMLJobInputDataConfig": @"",
                              @"OutputDataConfig": @"",
                              @"AutoMLProblemTypeConfig": @"",
                              @"RoleArn": @"",
                              @"Tags": @"",
                              @"SecurityConfig": @"",
                              @"AutoMLJobObjective": @"",
                              @"ModelDeployConfig": @"",
                              @"DataSplitConfig": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJobV2"]
                                                       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=SageMaker.CreateAutoMLJobV2" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AutoMLJobName\": \"\",\n  \"AutoMLJobInputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"AutoMLProblemTypeConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"SecurityConfig\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"ModelDeployConfig\": \"\",\n  \"DataSplitConfig\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJobV2",
  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([
    'AutoMLJobName' => '',
    'AutoMLJobInputDataConfig' => '',
    'OutputDataConfig' => '',
    'AutoMLProblemTypeConfig' => '',
    'RoleArn' => '',
    'Tags' => '',
    'SecurityConfig' => '',
    'AutoMLJobObjective' => '',
    'ModelDeployConfig' => '',
    'DataSplitConfig' => ''
  ]),
  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=SageMaker.CreateAutoMLJobV2', [
  'body' => '{
  "AutoMLJobName": "",
  "AutoMLJobInputDataConfig": "",
  "OutputDataConfig": "",
  "AutoMLProblemTypeConfig": "",
  "RoleArn": "",
  "Tags": "",
  "SecurityConfig": "",
  "AutoMLJobObjective": "",
  "ModelDeployConfig": "",
  "DataSplitConfig": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AutoMLJobName' => '',
  'AutoMLJobInputDataConfig' => '',
  'OutputDataConfig' => '',
  'AutoMLProblemTypeConfig' => '',
  'RoleArn' => '',
  'Tags' => '',
  'SecurityConfig' => '',
  'AutoMLJobObjective' => '',
  'ModelDeployConfig' => '',
  'DataSplitConfig' => ''
]));

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

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

append(json_encode([
  'AutoMLJobName' => '',
  'AutoMLJobInputDataConfig' => '',
  'OutputDataConfig' => '',
  'AutoMLProblemTypeConfig' => '',
  'RoleArn' => '',
  'Tags' => '',
  'SecurityConfig' => '',
  'AutoMLJobObjective' => '',
  'ModelDeployConfig' => '',
  'DataSplitConfig' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJobV2');
$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=SageMaker.CreateAutoMLJobV2' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AutoMLJobName": "",
  "AutoMLJobInputDataConfig": "",
  "OutputDataConfig": "",
  "AutoMLProblemTypeConfig": "",
  "RoleArn": "",
  "Tags": "",
  "SecurityConfig": "",
  "AutoMLJobObjective": "",
  "ModelDeployConfig": "",
  "DataSplitConfig": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJobV2' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AutoMLJobName": "",
  "AutoMLJobInputDataConfig": "",
  "OutputDataConfig": "",
  "AutoMLProblemTypeConfig": "",
  "RoleArn": "",
  "Tags": "",
  "SecurityConfig": "",
  "AutoMLJobObjective": "",
  "ModelDeployConfig": "",
  "DataSplitConfig": ""
}'

import http.client

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

payload = "{\n  \"AutoMLJobName\": \"\",\n  \"AutoMLJobInputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"AutoMLProblemTypeConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"SecurityConfig\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"ModelDeployConfig\": \"\",\n  \"DataSplitConfig\": \"\"\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=SageMaker.CreateAutoMLJobV2"

payload = {
    "AutoMLJobName": "",
    "AutoMLJobInputDataConfig": "",
    "OutputDataConfig": "",
    "AutoMLProblemTypeConfig": "",
    "RoleArn": "",
    "Tags": "",
    "SecurityConfig": "",
    "AutoMLJobObjective": "",
    "ModelDeployConfig": "",
    "DataSplitConfig": ""
}
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=SageMaker.CreateAutoMLJobV2"

payload <- "{\n  \"AutoMLJobName\": \"\",\n  \"AutoMLJobInputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"AutoMLProblemTypeConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"SecurityConfig\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"ModelDeployConfig\": \"\",\n  \"DataSplitConfig\": \"\"\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=SageMaker.CreateAutoMLJobV2")

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  \"AutoMLJobName\": \"\",\n  \"AutoMLJobInputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"AutoMLProblemTypeConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"SecurityConfig\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"ModelDeployConfig\": \"\",\n  \"DataSplitConfig\": \"\"\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  \"AutoMLJobName\": \"\",\n  \"AutoMLJobInputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"AutoMLProblemTypeConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"SecurityConfig\": \"\",\n  \"AutoMLJobObjective\": \"\",\n  \"ModelDeployConfig\": \"\",\n  \"DataSplitConfig\": \"\"\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=SageMaker.CreateAutoMLJobV2";

    let payload = json!({
        "AutoMLJobName": "",
        "AutoMLJobInputDataConfig": "",
        "OutputDataConfig": "",
        "AutoMLProblemTypeConfig": "",
        "RoleArn": "",
        "Tags": "",
        "SecurityConfig": "",
        "AutoMLJobObjective": "",
        "ModelDeployConfig": "",
        "DataSplitConfig": ""
    });

    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);
}

echo '{
  "AutoMLJobName": "",
  "AutoMLJobInputDataConfig": "",
  "OutputDataConfig": "",
  "AutoMLProblemTypeConfig": "",
  "RoleArn": "",
  "Tags": "",
  "SecurityConfig": "",
  "AutoMLJobObjective": "",
  "ModelDeployConfig": "",
  "DataSplitConfig": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJobV2' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AutoMLJobName": "",\n  "AutoMLJobInputDataConfig": "",\n  "OutputDataConfig": "",\n  "AutoMLProblemTypeConfig": "",\n  "RoleArn": "",\n  "Tags": "",\n  "SecurityConfig": "",\n  "AutoMLJobObjective": "",\n  "ModelDeployConfig": "",\n  "DataSplitConfig": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateAutoMLJobV2'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AutoMLJobName": "",
  "AutoMLJobInputDataConfig": "",
  "OutputDataConfig": "",
  "AutoMLProblemTypeConfig": "",
  "RoleArn": "",
  "Tags": "",
  "SecurityConfig": "",
  "AutoMLJobObjective": "",
  "ModelDeployConfig": "",
  "DataSplitConfig": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

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

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  \"CodeRepositoryName\": \"\",\n  \"GitConfig\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateCodeRepository" {:headers {:x-amz-target ""}
                                                                                         :content-type :json
                                                                                         :form-params {:CodeRepositoryName ""
                                                                                                       :GitConfig ""
                                                                                                       :Tags ""}})

require "http/client"

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

	payload := strings.NewReader("{\n  \"CodeRepositoryName\": \"\",\n  \"GitConfig\": \"\",\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: 63

{
  "CodeRepositoryName": "",
  "GitConfig": "",
  "Tags": ""
}

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

client.close();

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

const data = JSON.stringify({
  CodeRepositoryName: '',
  GitConfig: '',
  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=SageMaker.CreateCodeRepository');
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=SageMaker.CreateCodeRepository',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CodeRepositoryName: '', GitConfig: '', Tags: ''}
};

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

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

const request = require('request');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CodeRepositoryName' => '',
  'GitConfig' => '',
  'Tags' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"CodeRepositoryName\": \"\",\n  \"GitConfig\": \"\",\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=SageMaker.CreateCodeRepository"

payload = {
    "CodeRepositoryName": "",
    "GitConfig": "",
    "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=SageMaker.CreateCodeRepository"

payload <- "{\n  \"CodeRepositoryName\": \"\",\n  \"GitConfig\": \"\",\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=SageMaker.CreateCodeRepository")

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  \"CodeRepositoryName\": \"\",\n  \"GitConfig\": \"\",\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  \"CodeRepositoryName\": \"\",\n  \"GitConfig\": \"\",\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=SageMaker.CreateCodeRepository";

    let payload = json!({
        "CodeRepositoryName": "",
        "GitConfig": "",
        "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);
}

echo '{
  "CodeRepositoryName": "",
  "GitConfig": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateCodeRepository' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "CodeRepositoryName": "",\n  "GitConfig": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateCodeRepository'

import Foundation

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

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

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

CURL *hnd = curl_easy_init();

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

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  \"CompilationJobName\": \"\",\n  \"RoleArn\": \"\",\n  \"ModelPackageVersionArn\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateCompilationJob" {:headers {:x-amz-target ""}
                                                                                         :content-type :json
                                                                                         :form-params {:CompilationJobName ""
                                                                                                       :RoleArn ""
                                                                                                       :ModelPackageVersionArn ""
                                                                                                       :InputConfig ""
                                                                                                       :OutputConfig ""
                                                                                                       :VpcConfig ""
                                                                                                       :StoppingCondition ""
                                                                                                       :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateCompilationJob"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"CompilationJobName\": \"\",\n  \"RoleArn\": \"\",\n  \"ModelPackageVersionArn\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\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=SageMaker.CreateCompilationJob"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"CompilationJobName\": \"\",\n  \"RoleArn\": \"\",\n  \"ModelPackageVersionArn\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\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=SageMaker.CreateCompilationJob");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"CompilationJobName\": \"\",\n  \"RoleArn\": \"\",\n  \"ModelPackageVersionArn\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\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=SageMaker.CreateCompilationJob"

	payload := strings.NewReader("{\n  \"CompilationJobName\": \"\",\n  \"RoleArn\": \"\",\n  \"ModelPackageVersionArn\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\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: 182

{
  "CompilationJobName": "",
  "RoleArn": "",
  "ModelPackageVersionArn": "",
  "InputConfig": "",
  "OutputConfig": "",
  "VpcConfig": "",
  "StoppingCondition": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateCompilationJob")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"CompilationJobName\": \"\",\n  \"RoleArn\": \"\",\n  \"ModelPackageVersionArn\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateCompilationJob"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"CompilationJobName\": \"\",\n  \"RoleArn\": \"\",\n  \"ModelPackageVersionArn\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\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  \"CompilationJobName\": \"\",\n  \"RoleArn\": \"\",\n  \"ModelPackageVersionArn\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateCompilationJob")
  .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=SageMaker.CreateCompilationJob")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"CompilationJobName\": \"\",\n  \"RoleArn\": \"\",\n  \"ModelPackageVersionArn\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  CompilationJobName: '',
  RoleArn: '',
  ModelPackageVersionArn: '',
  InputConfig: '',
  OutputConfig: '',
  VpcConfig: '',
  StoppingCondition: '',
  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=SageMaker.CreateCompilationJob');
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=SageMaker.CreateCompilationJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    CompilationJobName: '',
    RoleArn: '',
    ModelPackageVersionArn: '',
    InputConfig: '',
    OutputConfig: '',
    VpcConfig: '',
    StoppingCondition: '',
    Tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateCompilationJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CompilationJobName":"","RoleArn":"","ModelPackageVersionArn":"","InputConfig":"","OutputConfig":"","VpcConfig":"","StoppingCondition":"","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=SageMaker.CreateCompilationJob',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CompilationJobName": "",\n  "RoleArn": "",\n  "ModelPackageVersionArn": "",\n  "InputConfig": "",\n  "OutputConfig": "",\n  "VpcConfig": "",\n  "StoppingCondition": "",\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  \"CompilationJobName\": \"\",\n  \"RoleArn\": \"\",\n  \"ModelPackageVersionArn\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateCompilationJob")
  .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({
  CompilationJobName: '',
  RoleArn: '',
  ModelPackageVersionArn: '',
  InputConfig: '',
  OutputConfig: '',
  VpcConfig: '',
  StoppingCondition: '',
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateCompilationJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    CompilationJobName: '',
    RoleArn: '',
    ModelPackageVersionArn: '',
    InputConfig: '',
    OutputConfig: '',
    VpcConfig: '',
    StoppingCondition: '',
    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=SageMaker.CreateCompilationJob');

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

req.type('json');
req.send({
  CompilationJobName: '',
  RoleArn: '',
  ModelPackageVersionArn: '',
  InputConfig: '',
  OutputConfig: '',
  VpcConfig: '',
  StoppingCondition: '',
  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=SageMaker.CreateCompilationJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    CompilationJobName: '',
    RoleArn: '',
    ModelPackageVersionArn: '',
    InputConfig: '',
    OutputConfig: '',
    VpcConfig: '',
    StoppingCondition: '',
    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=SageMaker.CreateCompilationJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CompilationJobName":"","RoleArn":"","ModelPackageVersionArn":"","InputConfig":"","OutputConfig":"","VpcConfig":"","StoppingCondition":"","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 = @{ @"CompilationJobName": @"",
                              @"RoleArn": @"",
                              @"ModelPackageVersionArn": @"",
                              @"InputConfig": @"",
                              @"OutputConfig": @"",
                              @"VpcConfig": @"",
                              @"StoppingCondition": @"",
                              @"Tags": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreateCompilationJob"]
                                                       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=SageMaker.CreateCompilationJob" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"CompilationJobName\": \"\",\n  \"RoleArn\": \"\",\n  \"ModelPackageVersionArn\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\n  \"Tags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateCompilationJob",
  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([
    'CompilationJobName' => '',
    'RoleArn' => '',
    'ModelPackageVersionArn' => '',
    'InputConfig' => '',
    'OutputConfig' => '',
    'VpcConfig' => '',
    'StoppingCondition' => '',
    '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=SageMaker.CreateCompilationJob', [
  'body' => '{
  "CompilationJobName": "",
  "RoleArn": "",
  "ModelPackageVersionArn": "",
  "InputConfig": "",
  "OutputConfig": "",
  "VpcConfig": "",
  "StoppingCondition": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CompilationJobName' => '',
  'RoleArn' => '',
  'ModelPackageVersionArn' => '',
  'InputConfig' => '',
  'OutputConfig' => '',
  'VpcConfig' => '',
  'StoppingCondition' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'CompilationJobName' => '',
  'RoleArn' => '',
  'ModelPackageVersionArn' => '',
  'InputConfig' => '',
  'OutputConfig' => '',
  'VpcConfig' => '',
  'StoppingCondition' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateCompilationJob');
$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=SageMaker.CreateCompilationJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CompilationJobName": "",
  "RoleArn": "",
  "ModelPackageVersionArn": "",
  "InputConfig": "",
  "OutputConfig": "",
  "VpcConfig": "",
  "StoppingCondition": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateCompilationJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CompilationJobName": "",
  "RoleArn": "",
  "ModelPackageVersionArn": "",
  "InputConfig": "",
  "OutputConfig": "",
  "VpcConfig": "",
  "StoppingCondition": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"CompilationJobName\": \"\",\n  \"RoleArn\": \"\",\n  \"ModelPackageVersionArn\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\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=SageMaker.CreateCompilationJob"

payload = {
    "CompilationJobName": "",
    "RoleArn": "",
    "ModelPackageVersionArn": "",
    "InputConfig": "",
    "OutputConfig": "",
    "VpcConfig": "",
    "StoppingCondition": "",
    "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=SageMaker.CreateCompilationJob"

payload <- "{\n  \"CompilationJobName\": \"\",\n  \"RoleArn\": \"\",\n  \"ModelPackageVersionArn\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\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=SageMaker.CreateCompilationJob")

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  \"CompilationJobName\": \"\",\n  \"RoleArn\": \"\",\n  \"ModelPackageVersionArn\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\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  \"CompilationJobName\": \"\",\n  \"RoleArn\": \"\",\n  \"ModelPackageVersionArn\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\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=SageMaker.CreateCompilationJob";

    let payload = json!({
        "CompilationJobName": "",
        "RoleArn": "",
        "ModelPackageVersionArn": "",
        "InputConfig": "",
        "OutputConfig": "",
        "VpcConfig": "",
        "StoppingCondition": "",
        "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);
}

echo '{
  "CompilationJobName": "",
  "RoleArn": "",
  "ModelPackageVersionArn": "",
  "InputConfig": "",
  "OutputConfig": "",
  "VpcConfig": "",
  "StoppingCondition": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateCompilationJob' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "CompilationJobName": "",\n  "RoleArn": "",\n  "ModelPackageVersionArn": "",\n  "InputConfig": "",\n  "OutputConfig": "",\n  "VpcConfig": "",\n  "StoppingCondition": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateCompilationJob'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "CompilationJobName": "",
  "RoleArn": "",
  "ModelPackageVersionArn": "",
  "InputConfig": "",
  "OutputConfig": "",
  "VpcConfig": "",
  "StoppingCondition": "",
  "Tags": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

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

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  \"ContextName\": \"\",\n  \"Source\": \"\",\n  \"ContextType\": \"\",\n  \"Description\": \"\",\n  \"Properties\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateContext" {:headers {:x-amz-target ""}
                                                                                  :content-type :json
                                                                                  :form-params {:ContextName ""
                                                                                                :Source ""
                                                                                                :ContextType ""
                                                                                                :Description ""
                                                                                                :Properties ""
                                                                                                :Tags ""}})

require "http/client"

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

	payload := strings.NewReader("{\n  \"ContextName\": \"\",\n  \"Source\": \"\",\n  \"ContextType\": \"\",\n  \"Description\": \"\",\n  \"Properties\": \"\",\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: 115

{
  "ContextName": "",
  "Source": "",
  "ContextType": "",
  "Description": "",
  "Properties": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateContext")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ContextName\": \"\",\n  \"Source\": \"\",\n  \"ContextType\": \"\",\n  \"Description\": \"\",\n  \"Properties\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

const data = JSON.stringify({
  ContextName: '',
  Source: '',
  ContextType: '',
  Description: '',
  Properties: '',
  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=SageMaker.CreateContext');
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=SageMaker.CreateContext',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ContextName: '',
    Source: '',
    ContextType: '',
    Description: '',
    Properties: '',
    Tags: ''
  }
};

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

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateContext',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ContextName: '',
    Source: '',
    ContextType: '',
    Description: '',
    Properties: '',
    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=SageMaker.CreateContext');

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

req.type('json');
req.send({
  ContextName: '',
  Source: '',
  ContextType: '',
  Description: '',
  Properties: '',
  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=SageMaker.CreateContext',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ContextName: '',
    Source: '',
    ContextType: '',
    Description: '',
    Properties: '',
    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=SageMaker.CreateContext';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ContextName":"","Source":"","ContextType":"","Description":"","Properties":"","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 = @{ @"ContextName": @"",
                              @"Source": @"",
                              @"ContextType": @"",
                              @"Description": @"",
                              @"Properties": @"",
                              @"Tags": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateContext",
  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([
    'ContextName' => '',
    'Source' => '',
    'ContextType' => '',
    'Description' => '',
    'Properties' => '',
    '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=SageMaker.CreateContext', [
  'body' => '{
  "ContextName": "",
  "Source": "",
  "ContextType": "",
  "Description": "",
  "Properties": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ContextName' => '',
  'Source' => '',
  'ContextType' => '',
  'Description' => '',
  'Properties' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'ContextName' => '',
  'Source' => '',
  'ContextType' => '',
  'Description' => '',
  'Properties' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateContext');
$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=SageMaker.CreateContext' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ContextName": "",
  "Source": "",
  "ContextType": "",
  "Description": "",
  "Properties": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateContext' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ContextName": "",
  "Source": "",
  "ContextType": "",
  "Description": "",
  "Properties": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"ContextName\": \"\",\n  \"Source\": \"\",\n  \"ContextType\": \"\",\n  \"Description\": \"\",\n  \"Properties\": \"\",\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=SageMaker.CreateContext"

payload = {
    "ContextName": "",
    "Source": "",
    "ContextType": "",
    "Description": "",
    "Properties": "",
    "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=SageMaker.CreateContext"

payload <- "{\n  \"ContextName\": \"\",\n  \"Source\": \"\",\n  \"ContextType\": \"\",\n  \"Description\": \"\",\n  \"Properties\": \"\",\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=SageMaker.CreateContext")

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  \"ContextName\": \"\",\n  \"Source\": \"\",\n  \"ContextType\": \"\",\n  \"Description\": \"\",\n  \"Properties\": \"\",\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  \"ContextName\": \"\",\n  \"Source\": \"\",\n  \"ContextType\": \"\",\n  \"Description\": \"\",\n  \"Properties\": \"\",\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=SageMaker.CreateContext";

    let payload = json!({
        "ContextName": "",
        "Source": "",
        "ContextType": "",
        "Description": "",
        "Properties": "",
        "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);
}

echo '{
  "ContextName": "",
  "Source": "",
  "ContextType": "",
  "Description": "",
  "Properties": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateContext' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ContextName": "",\n  "Source": "",\n  "ContextType": "",\n  "Description": "",\n  "Properties": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateContext'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ContextName": "",
  "Source": "",
  "ContextType": "",
  "Description": "",
  "Properties": "",
  "Tags": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

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

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  \"JobDefinitionName\": \"\",\n  \"DataQualityBaselineConfig\": \"\",\n  \"DataQualityAppSpecification\": \"\",\n  \"DataQualityJobInput\": \"\",\n  \"DataQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDataQualityJobDefinition" {:headers {:x-amz-target ""}
                                                                                                   :content-type :json
                                                                                                   :form-params {:JobDefinitionName ""
                                                                                                                 :DataQualityBaselineConfig ""
                                                                                                                 :DataQualityAppSpecification ""
                                                                                                                 :DataQualityJobInput ""
                                                                                                                 :DataQualityJobOutputConfig {:MonitoringOutputs ""
                                                                                                                                              :KmsKeyId ""}
                                                                                                                 :JobResources {:ClusterConfig ""}
                                                                                                                 :NetworkConfig ""
                                                                                                                 :RoleArn ""
                                                                                                                 :StoppingCondition {:MaxRuntimeInSeconds ""}
                                                                                                                 :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDataQualityJobDefinition"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"JobDefinitionName\": \"\",\n  \"DataQualityBaselineConfig\": \"\",\n  \"DataQualityAppSpecification\": \"\",\n  \"DataQualityJobInput\": \"\",\n  \"DataQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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=SageMaker.CreateDataQualityJobDefinition"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"JobDefinitionName\": \"\",\n  \"DataQualityBaselineConfig\": \"\",\n  \"DataQualityAppSpecification\": \"\",\n  \"DataQualityJobInput\": \"\",\n  \"DataQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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=SageMaker.CreateDataQualityJobDefinition");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"JobDefinitionName\": \"\",\n  \"DataQualityBaselineConfig\": \"\",\n  \"DataQualityAppSpecification\": \"\",\n  \"DataQualityJobInput\": \"\",\n  \"DataQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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=SageMaker.CreateDataQualityJobDefinition"

	payload := strings.NewReader("{\n  \"JobDefinitionName\": \"\",\n  \"DataQualityBaselineConfig\": \"\",\n  \"DataQualityAppSpecification\": \"\",\n  \"DataQualityJobInput\": \"\",\n  \"DataQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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: 380

{
  "JobDefinitionName": "",
  "DataQualityBaselineConfig": "",
  "DataQualityAppSpecification": "",
  "DataQualityJobInput": "",
  "DataQualityJobOutputConfig": {
    "MonitoringOutputs": "",
    "KmsKeyId": ""
  },
  "JobResources": {
    "ClusterConfig": ""
  },
  "NetworkConfig": "",
  "RoleArn": "",
  "StoppingCondition": {
    "MaxRuntimeInSeconds": ""
  },
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDataQualityJobDefinition")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"JobDefinitionName\": \"\",\n  \"DataQualityBaselineConfig\": \"\",\n  \"DataQualityAppSpecification\": \"\",\n  \"DataQualityJobInput\": \"\",\n  \"DataQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDataQualityJobDefinition"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"JobDefinitionName\": \"\",\n  \"DataQualityBaselineConfig\": \"\",\n  \"DataQualityAppSpecification\": \"\",\n  \"DataQualityJobInput\": \"\",\n  \"DataQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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  \"JobDefinitionName\": \"\",\n  \"DataQualityBaselineConfig\": \"\",\n  \"DataQualityAppSpecification\": \"\",\n  \"DataQualityJobInput\": \"\",\n  \"DataQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDataQualityJobDefinition")
  .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=SageMaker.CreateDataQualityJobDefinition")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"JobDefinitionName\": \"\",\n  \"DataQualityBaselineConfig\": \"\",\n  \"DataQualityAppSpecification\": \"\",\n  \"DataQualityJobInput\": \"\",\n  \"DataQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  JobDefinitionName: '',
  DataQualityBaselineConfig: '',
  DataQualityAppSpecification: '',
  DataQualityJobInput: '',
  DataQualityJobOutputConfig: {
    MonitoringOutputs: '',
    KmsKeyId: ''
  },
  JobResources: {
    ClusterConfig: ''
  },
  NetworkConfig: '',
  RoleArn: '',
  StoppingCondition: {
    MaxRuntimeInSeconds: ''
  },
  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=SageMaker.CreateDataQualityJobDefinition');
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=SageMaker.CreateDataQualityJobDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    JobDefinitionName: '',
    DataQualityBaselineConfig: '',
    DataQualityAppSpecification: '',
    DataQualityJobInput: '',
    DataQualityJobOutputConfig: {MonitoringOutputs: '', KmsKeyId: ''},
    JobResources: {ClusterConfig: ''},
    NetworkConfig: '',
    RoleArn: '',
    StoppingCondition: {MaxRuntimeInSeconds: ''},
    Tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDataQualityJobDefinition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"JobDefinitionName":"","DataQualityBaselineConfig":"","DataQualityAppSpecification":"","DataQualityJobInput":"","DataQualityJobOutputConfig":{"MonitoringOutputs":"","KmsKeyId":""},"JobResources":{"ClusterConfig":""},"NetworkConfig":"","RoleArn":"","StoppingCondition":{"MaxRuntimeInSeconds":""},"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=SageMaker.CreateDataQualityJobDefinition',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "JobDefinitionName": "",\n  "DataQualityBaselineConfig": "",\n  "DataQualityAppSpecification": "",\n  "DataQualityJobInput": "",\n  "DataQualityJobOutputConfig": {\n    "MonitoringOutputs": "",\n    "KmsKeyId": ""\n  },\n  "JobResources": {\n    "ClusterConfig": ""\n  },\n  "NetworkConfig": "",\n  "RoleArn": "",\n  "StoppingCondition": {\n    "MaxRuntimeInSeconds": ""\n  },\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  \"JobDefinitionName\": \"\",\n  \"DataQualityBaselineConfig\": \"\",\n  \"DataQualityAppSpecification\": \"\",\n  \"DataQualityJobInput\": \"\",\n  \"DataQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDataQualityJobDefinition")
  .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({
  JobDefinitionName: '',
  DataQualityBaselineConfig: '',
  DataQualityAppSpecification: '',
  DataQualityJobInput: '',
  DataQualityJobOutputConfig: {MonitoringOutputs: '', KmsKeyId: ''},
  JobResources: {ClusterConfig: ''},
  NetworkConfig: '',
  RoleArn: '',
  StoppingCondition: {MaxRuntimeInSeconds: ''},
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDataQualityJobDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    JobDefinitionName: '',
    DataQualityBaselineConfig: '',
    DataQualityAppSpecification: '',
    DataQualityJobInput: '',
    DataQualityJobOutputConfig: {MonitoringOutputs: '', KmsKeyId: ''},
    JobResources: {ClusterConfig: ''},
    NetworkConfig: '',
    RoleArn: '',
    StoppingCondition: {MaxRuntimeInSeconds: ''},
    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=SageMaker.CreateDataQualityJobDefinition');

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

req.type('json');
req.send({
  JobDefinitionName: '',
  DataQualityBaselineConfig: '',
  DataQualityAppSpecification: '',
  DataQualityJobInput: '',
  DataQualityJobOutputConfig: {
    MonitoringOutputs: '',
    KmsKeyId: ''
  },
  JobResources: {
    ClusterConfig: ''
  },
  NetworkConfig: '',
  RoleArn: '',
  StoppingCondition: {
    MaxRuntimeInSeconds: ''
  },
  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=SageMaker.CreateDataQualityJobDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    JobDefinitionName: '',
    DataQualityBaselineConfig: '',
    DataQualityAppSpecification: '',
    DataQualityJobInput: '',
    DataQualityJobOutputConfig: {MonitoringOutputs: '', KmsKeyId: ''},
    JobResources: {ClusterConfig: ''},
    NetworkConfig: '',
    RoleArn: '',
    StoppingCondition: {MaxRuntimeInSeconds: ''},
    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=SageMaker.CreateDataQualityJobDefinition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"JobDefinitionName":"","DataQualityBaselineConfig":"","DataQualityAppSpecification":"","DataQualityJobInput":"","DataQualityJobOutputConfig":{"MonitoringOutputs":"","KmsKeyId":""},"JobResources":{"ClusterConfig":""},"NetworkConfig":"","RoleArn":"","StoppingCondition":{"MaxRuntimeInSeconds":""},"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 = @{ @"JobDefinitionName": @"",
                              @"DataQualityBaselineConfig": @"",
                              @"DataQualityAppSpecification": @"",
                              @"DataQualityJobInput": @"",
                              @"DataQualityJobOutputConfig": @{ @"MonitoringOutputs": @"", @"KmsKeyId": @"" },
                              @"JobResources": @{ @"ClusterConfig": @"" },
                              @"NetworkConfig": @"",
                              @"RoleArn": @"",
                              @"StoppingCondition": @{ @"MaxRuntimeInSeconds": @"" },
                              @"Tags": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDataQualityJobDefinition"]
                                                       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=SageMaker.CreateDataQualityJobDefinition" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"JobDefinitionName\": \"\",\n  \"DataQualityBaselineConfig\": \"\",\n  \"DataQualityAppSpecification\": \"\",\n  \"DataQualityJobInput\": \"\",\n  \"DataQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\n  \"Tags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDataQualityJobDefinition",
  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([
    'JobDefinitionName' => '',
    'DataQualityBaselineConfig' => '',
    'DataQualityAppSpecification' => '',
    'DataQualityJobInput' => '',
    'DataQualityJobOutputConfig' => [
        'MonitoringOutputs' => '',
        'KmsKeyId' => ''
    ],
    'JobResources' => [
        'ClusterConfig' => ''
    ],
    'NetworkConfig' => '',
    'RoleArn' => '',
    'StoppingCondition' => [
        'MaxRuntimeInSeconds' => ''
    ],
    '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=SageMaker.CreateDataQualityJobDefinition', [
  'body' => '{
  "JobDefinitionName": "",
  "DataQualityBaselineConfig": "",
  "DataQualityAppSpecification": "",
  "DataQualityJobInput": "",
  "DataQualityJobOutputConfig": {
    "MonitoringOutputs": "",
    "KmsKeyId": ""
  },
  "JobResources": {
    "ClusterConfig": ""
  },
  "NetworkConfig": "",
  "RoleArn": "",
  "StoppingCondition": {
    "MaxRuntimeInSeconds": ""
  },
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'JobDefinitionName' => '',
  'DataQualityBaselineConfig' => '',
  'DataQualityAppSpecification' => '',
  'DataQualityJobInput' => '',
  'DataQualityJobOutputConfig' => [
    'MonitoringOutputs' => '',
    'KmsKeyId' => ''
  ],
  'JobResources' => [
    'ClusterConfig' => ''
  ],
  'NetworkConfig' => '',
  'RoleArn' => '',
  'StoppingCondition' => [
    'MaxRuntimeInSeconds' => ''
  ],
  'Tags' => ''
]));

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

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

append(json_encode([
  'JobDefinitionName' => '',
  'DataQualityBaselineConfig' => '',
  'DataQualityAppSpecification' => '',
  'DataQualityJobInput' => '',
  'DataQualityJobOutputConfig' => [
    'MonitoringOutputs' => '',
    'KmsKeyId' => ''
  ],
  'JobResources' => [
    'ClusterConfig' => ''
  ],
  'NetworkConfig' => '',
  'RoleArn' => '',
  'StoppingCondition' => [
    'MaxRuntimeInSeconds' => ''
  ],
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDataQualityJobDefinition');
$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=SageMaker.CreateDataQualityJobDefinition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "JobDefinitionName": "",
  "DataQualityBaselineConfig": "",
  "DataQualityAppSpecification": "",
  "DataQualityJobInput": "",
  "DataQualityJobOutputConfig": {
    "MonitoringOutputs": "",
    "KmsKeyId": ""
  },
  "JobResources": {
    "ClusterConfig": ""
  },
  "NetworkConfig": "",
  "RoleArn": "",
  "StoppingCondition": {
    "MaxRuntimeInSeconds": ""
  },
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDataQualityJobDefinition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "JobDefinitionName": "",
  "DataQualityBaselineConfig": "",
  "DataQualityAppSpecification": "",
  "DataQualityJobInput": "",
  "DataQualityJobOutputConfig": {
    "MonitoringOutputs": "",
    "KmsKeyId": ""
  },
  "JobResources": {
    "ClusterConfig": ""
  },
  "NetworkConfig": "",
  "RoleArn": "",
  "StoppingCondition": {
    "MaxRuntimeInSeconds": ""
  },
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"JobDefinitionName\": \"\",\n  \"DataQualityBaselineConfig\": \"\",\n  \"DataQualityAppSpecification\": \"\",\n  \"DataQualityJobInput\": \"\",\n  \"DataQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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=SageMaker.CreateDataQualityJobDefinition"

payload = {
    "JobDefinitionName": "",
    "DataQualityBaselineConfig": "",
    "DataQualityAppSpecification": "",
    "DataQualityJobInput": "",
    "DataQualityJobOutputConfig": {
        "MonitoringOutputs": "",
        "KmsKeyId": ""
    },
    "JobResources": { "ClusterConfig": "" },
    "NetworkConfig": "",
    "RoleArn": "",
    "StoppingCondition": { "MaxRuntimeInSeconds": "" },
    "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=SageMaker.CreateDataQualityJobDefinition"

payload <- "{\n  \"JobDefinitionName\": \"\",\n  \"DataQualityBaselineConfig\": \"\",\n  \"DataQualityAppSpecification\": \"\",\n  \"DataQualityJobInput\": \"\",\n  \"DataQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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=SageMaker.CreateDataQualityJobDefinition")

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  \"JobDefinitionName\": \"\",\n  \"DataQualityBaselineConfig\": \"\",\n  \"DataQualityAppSpecification\": \"\",\n  \"DataQualityJobInput\": \"\",\n  \"DataQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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  \"JobDefinitionName\": \"\",\n  \"DataQualityBaselineConfig\": \"\",\n  \"DataQualityAppSpecification\": \"\",\n  \"DataQualityJobInput\": \"\",\n  \"DataQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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=SageMaker.CreateDataQualityJobDefinition";

    let payload = json!({
        "JobDefinitionName": "",
        "DataQualityBaselineConfig": "",
        "DataQualityAppSpecification": "",
        "DataQualityJobInput": "",
        "DataQualityJobOutputConfig": json!({
            "MonitoringOutputs": "",
            "KmsKeyId": ""
        }),
        "JobResources": json!({"ClusterConfig": ""}),
        "NetworkConfig": "",
        "RoleArn": "",
        "StoppingCondition": json!({"MaxRuntimeInSeconds": ""}),
        "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);
}

echo '{
  "JobDefinitionName": "",
  "DataQualityBaselineConfig": "",
  "DataQualityAppSpecification": "",
  "DataQualityJobInput": "",
  "DataQualityJobOutputConfig": {
    "MonitoringOutputs": "",
    "KmsKeyId": ""
  },
  "JobResources": {
    "ClusterConfig": ""
  },
  "NetworkConfig": "",
  "RoleArn": "",
  "StoppingCondition": {
    "MaxRuntimeInSeconds": ""
  },
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDataQualityJobDefinition' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "JobDefinitionName": "",\n  "DataQualityBaselineConfig": "",\n  "DataQualityAppSpecification": "",\n  "DataQualityJobInput": "",\n  "DataQualityJobOutputConfig": {\n    "MonitoringOutputs": "",\n    "KmsKeyId": ""\n  },\n  "JobResources": {\n    "ClusterConfig": ""\n  },\n  "NetworkConfig": "",\n  "RoleArn": "",\n  "StoppingCondition": {\n    "MaxRuntimeInSeconds": ""\n  },\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDataQualityJobDefinition'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "JobDefinitionName": "",
  "DataQualityBaselineConfig": "",
  "DataQualityAppSpecification": "",
  "DataQualityJobInput": "",
  "DataQualityJobOutputConfig": [
    "MonitoringOutputs": "",
    "KmsKeyId": ""
  ],
  "JobResources": ["ClusterConfig": ""],
  "NetworkConfig": "",
  "RoleArn": "",
  "StoppingCondition": ["MaxRuntimeInSeconds": ""],
  "Tags": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

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

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  \"DeviceFleetName\": \"\",\n  \"RoleArn\": \"\",\n  \"Description\": \"\",\n  \"OutputConfig\": \"\",\n  \"Tags\": \"\",\n  \"EnableIotRoleAlias\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDeviceFleet" {:headers {:x-amz-target ""}
                                                                                      :content-type :json
                                                                                      :form-params {:DeviceFleetName ""
                                                                                                    :RoleArn ""
                                                                                                    :Description ""
                                                                                                    :OutputConfig ""
                                                                                                    :Tags ""
                                                                                                    :EnableIotRoleAlias ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDeviceFleet"

	payload := strings.NewReader("{\n  \"DeviceFleetName\": \"\",\n  \"RoleArn\": \"\",\n  \"Description\": \"\",\n  \"OutputConfig\": \"\",\n  \"Tags\": \"\",\n  \"EnableIotRoleAlias\": \"\"\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: 129

{
  "DeviceFleetName": "",
  "RoleArn": "",
  "Description": "",
  "OutputConfig": "",
  "Tags": "",
  "EnableIotRoleAlias": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDeviceFleet")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DeviceFleetName\": \"\",\n  \"RoleArn\": \"\",\n  \"Description\": \"\",\n  \"OutputConfig\": \"\",\n  \"Tags\": \"\",\n  \"EnableIotRoleAlias\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

const data = JSON.stringify({
  DeviceFleetName: '',
  RoleArn: '',
  Description: '',
  OutputConfig: '',
  Tags: '',
  EnableIotRoleAlias: ''
});

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=SageMaker.CreateDeviceFleet');
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=SageMaker.CreateDeviceFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    DeviceFleetName: '',
    RoleArn: '',
    Description: '',
    OutputConfig: '',
    Tags: '',
    EnableIotRoleAlias: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDeviceFleet';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DeviceFleetName":"","RoleArn":"","Description":"","OutputConfig":"","Tags":"","EnableIotRoleAlias":""}'
};

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=SageMaker.CreateDeviceFleet',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DeviceFleetName": "",\n  "RoleArn": "",\n  "Description": "",\n  "OutputConfig": "",\n  "Tags": "",\n  "EnableIotRoleAlias": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DeviceFleetName\": \"\",\n  \"RoleArn\": \"\",\n  \"Description\": \"\",\n  \"OutputConfig\": \"\",\n  \"Tags\": \"\",\n  \"EnableIotRoleAlias\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDeviceFleet")
  .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({
  DeviceFleetName: '',
  RoleArn: '',
  Description: '',
  OutputConfig: '',
  Tags: '',
  EnableIotRoleAlias: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDeviceFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    DeviceFleetName: '',
    RoleArn: '',
    Description: '',
    OutputConfig: '',
    Tags: '',
    EnableIotRoleAlias: ''
  },
  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=SageMaker.CreateDeviceFleet');

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

req.type('json');
req.send({
  DeviceFleetName: '',
  RoleArn: '',
  Description: '',
  OutputConfig: '',
  Tags: '',
  EnableIotRoleAlias: ''
});

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=SageMaker.CreateDeviceFleet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    DeviceFleetName: '',
    RoleArn: '',
    Description: '',
    OutputConfig: '',
    Tags: '',
    EnableIotRoleAlias: ''
  }
};

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=SageMaker.CreateDeviceFleet';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DeviceFleetName":"","RoleArn":"","Description":"","OutputConfig":"","Tags":"","EnableIotRoleAlias":""}'
};

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 = @{ @"DeviceFleetName": @"",
                              @"RoleArn": @"",
                              @"Description": @"",
                              @"OutputConfig": @"",
                              @"Tags": @"",
                              @"EnableIotRoleAlias": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDeviceFleet",
  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([
    'DeviceFleetName' => '',
    'RoleArn' => '',
    'Description' => '',
    'OutputConfig' => '',
    'Tags' => '',
    'EnableIotRoleAlias' => ''
  ]),
  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=SageMaker.CreateDeviceFleet', [
  'body' => '{
  "DeviceFleetName": "",
  "RoleArn": "",
  "Description": "",
  "OutputConfig": "",
  "Tags": "",
  "EnableIotRoleAlias": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DeviceFleetName' => '',
  'RoleArn' => '',
  'Description' => '',
  'OutputConfig' => '',
  'Tags' => '',
  'EnableIotRoleAlias' => ''
]));

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

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

append(json_encode([
  'DeviceFleetName' => '',
  'RoleArn' => '',
  'Description' => '',
  'OutputConfig' => '',
  'Tags' => '',
  'EnableIotRoleAlias' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDeviceFleet');
$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=SageMaker.CreateDeviceFleet' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DeviceFleetName": "",
  "RoleArn": "",
  "Description": "",
  "OutputConfig": "",
  "Tags": "",
  "EnableIotRoleAlias": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDeviceFleet' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DeviceFleetName": "",
  "RoleArn": "",
  "Description": "",
  "OutputConfig": "",
  "Tags": "",
  "EnableIotRoleAlias": ""
}'

import http.client

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

payload = "{\n  \"DeviceFleetName\": \"\",\n  \"RoleArn\": \"\",\n  \"Description\": \"\",\n  \"OutputConfig\": \"\",\n  \"Tags\": \"\",\n  \"EnableIotRoleAlias\": \"\"\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=SageMaker.CreateDeviceFleet"

payload = {
    "DeviceFleetName": "",
    "RoleArn": "",
    "Description": "",
    "OutputConfig": "",
    "Tags": "",
    "EnableIotRoleAlias": ""
}
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=SageMaker.CreateDeviceFleet"

payload <- "{\n  \"DeviceFleetName\": \"\",\n  \"RoleArn\": \"\",\n  \"Description\": \"\",\n  \"OutputConfig\": \"\",\n  \"Tags\": \"\",\n  \"EnableIotRoleAlias\": \"\"\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=SageMaker.CreateDeviceFleet")

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  \"DeviceFleetName\": \"\",\n  \"RoleArn\": \"\",\n  \"Description\": \"\",\n  \"OutputConfig\": \"\",\n  \"Tags\": \"\",\n  \"EnableIotRoleAlias\": \"\"\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  \"DeviceFleetName\": \"\",\n  \"RoleArn\": \"\",\n  \"Description\": \"\",\n  \"OutputConfig\": \"\",\n  \"Tags\": \"\",\n  \"EnableIotRoleAlias\": \"\"\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=SageMaker.CreateDeviceFleet";

    let payload = json!({
        "DeviceFleetName": "",
        "RoleArn": "",
        "Description": "",
        "OutputConfig": "",
        "Tags": "",
        "EnableIotRoleAlias": ""
    });

    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);
}

echo '{
  "DeviceFleetName": "",
  "RoleArn": "",
  "Description": "",
  "OutputConfig": "",
  "Tags": "",
  "EnableIotRoleAlias": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDeviceFleet' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "DeviceFleetName": "",\n  "RoleArn": "",\n  "Description": "",\n  "OutputConfig": "",\n  "Tags": "",\n  "EnableIotRoleAlias": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDeviceFleet'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "DeviceFleetName": "",
  "RoleArn": "",
  "Description": "",
  "OutputConfig": "",
  "Tags": "",
  "EnableIotRoleAlias": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

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

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  \"DomainName\": \"\",\n  \"AuthMode\": \"\",\n  \"DefaultUserSettings\": \"\",\n  \"SubnetIds\": \"\",\n  \"VpcId\": \"\",\n  \"Tags\": \"\",\n  \"AppNetworkAccessType\": \"\",\n  \"HomeEfsFileSystemKmsKeyId\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AppSecurityGroupManagement\": \"\",\n  \"DomainSettings\": \"\",\n  \"DefaultSpaceSettings\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDomain" {:headers {:x-amz-target ""}
                                                                                 :content-type :json
                                                                                 :form-params {:DomainName ""
                                                                                               :AuthMode ""
                                                                                               :DefaultUserSettings ""
                                                                                               :SubnetIds ""
                                                                                               :VpcId ""
                                                                                               :Tags ""
                                                                                               :AppNetworkAccessType ""
                                                                                               :HomeEfsFileSystemKmsKeyId ""
                                                                                               :KmsKeyId ""
                                                                                               :AppSecurityGroupManagement ""
                                                                                               :DomainSettings ""
                                                                                               :DefaultSpaceSettings ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDomain"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"DomainName\": \"\",\n  \"AuthMode\": \"\",\n  \"DefaultUserSettings\": \"\",\n  \"SubnetIds\": \"\",\n  \"VpcId\": \"\",\n  \"Tags\": \"\",\n  \"AppNetworkAccessType\": \"\",\n  \"HomeEfsFileSystemKmsKeyId\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AppSecurityGroupManagement\": \"\",\n  \"DomainSettings\": \"\",\n  \"DefaultSpaceSettings\": \"\"\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=SageMaker.CreateDomain"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"DomainName\": \"\",\n  \"AuthMode\": \"\",\n  \"DefaultUserSettings\": \"\",\n  \"SubnetIds\": \"\",\n  \"VpcId\": \"\",\n  \"Tags\": \"\",\n  \"AppNetworkAccessType\": \"\",\n  \"HomeEfsFileSystemKmsKeyId\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AppSecurityGroupManagement\": \"\",\n  \"DomainSettings\": \"\",\n  \"DefaultSpaceSettings\": \"\"\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=SageMaker.CreateDomain");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DomainName\": \"\",\n  \"AuthMode\": \"\",\n  \"DefaultUserSettings\": \"\",\n  \"SubnetIds\": \"\",\n  \"VpcId\": \"\",\n  \"Tags\": \"\",\n  \"AppNetworkAccessType\": \"\",\n  \"HomeEfsFileSystemKmsKeyId\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AppSecurityGroupManagement\": \"\",\n  \"DomainSettings\": \"\",\n  \"DefaultSpaceSettings\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDomain"

	payload := strings.NewReader("{\n  \"DomainName\": \"\",\n  \"AuthMode\": \"\",\n  \"DefaultUserSettings\": \"\",\n  \"SubnetIds\": \"\",\n  \"VpcId\": \"\",\n  \"Tags\": \"\",\n  \"AppNetworkAccessType\": \"\",\n  \"HomeEfsFileSystemKmsKeyId\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AppSecurityGroupManagement\": \"\",\n  \"DomainSettings\": \"\",\n  \"DefaultSpaceSettings\": \"\"\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: 290

{
  "DomainName": "",
  "AuthMode": "",
  "DefaultUserSettings": "",
  "SubnetIds": "",
  "VpcId": "",
  "Tags": "",
  "AppNetworkAccessType": "",
  "HomeEfsFileSystemKmsKeyId": "",
  "KmsKeyId": "",
  "AppSecurityGroupManagement": "",
  "DomainSettings": "",
  "DefaultSpaceSettings": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDomain")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DomainName\": \"\",\n  \"AuthMode\": \"\",\n  \"DefaultUserSettings\": \"\",\n  \"SubnetIds\": \"\",\n  \"VpcId\": \"\",\n  \"Tags\": \"\",\n  \"AppNetworkAccessType\": \"\",\n  \"HomeEfsFileSystemKmsKeyId\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AppSecurityGroupManagement\": \"\",\n  \"DomainSettings\": \"\",\n  \"DefaultSpaceSettings\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDomain"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"DomainName\": \"\",\n  \"AuthMode\": \"\",\n  \"DefaultUserSettings\": \"\",\n  \"SubnetIds\": \"\",\n  \"VpcId\": \"\",\n  \"Tags\": \"\",\n  \"AppNetworkAccessType\": \"\",\n  \"HomeEfsFileSystemKmsKeyId\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AppSecurityGroupManagement\": \"\",\n  \"DomainSettings\": \"\",\n  \"DefaultSpaceSettings\": \"\"\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  \"DomainName\": \"\",\n  \"AuthMode\": \"\",\n  \"DefaultUserSettings\": \"\",\n  \"SubnetIds\": \"\",\n  \"VpcId\": \"\",\n  \"Tags\": \"\",\n  \"AppNetworkAccessType\": \"\",\n  \"HomeEfsFileSystemKmsKeyId\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AppSecurityGroupManagement\": \"\",\n  \"DomainSettings\": \"\",\n  \"DefaultSpaceSettings\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDomain")
  .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=SageMaker.CreateDomain")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"DomainName\": \"\",\n  \"AuthMode\": \"\",\n  \"DefaultUserSettings\": \"\",\n  \"SubnetIds\": \"\",\n  \"VpcId\": \"\",\n  \"Tags\": \"\",\n  \"AppNetworkAccessType\": \"\",\n  \"HomeEfsFileSystemKmsKeyId\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AppSecurityGroupManagement\": \"\",\n  \"DomainSettings\": \"\",\n  \"DefaultSpaceSettings\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  DomainName: '',
  AuthMode: '',
  DefaultUserSettings: '',
  SubnetIds: '',
  VpcId: '',
  Tags: '',
  AppNetworkAccessType: '',
  HomeEfsFileSystemKmsKeyId: '',
  KmsKeyId: '',
  AppSecurityGroupManagement: '',
  DomainSettings: '',
  DefaultSpaceSettings: ''
});

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=SageMaker.CreateDomain');
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=SageMaker.CreateDomain',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    DomainName: '',
    AuthMode: '',
    DefaultUserSettings: '',
    SubnetIds: '',
    VpcId: '',
    Tags: '',
    AppNetworkAccessType: '',
    HomeEfsFileSystemKmsKeyId: '',
    KmsKeyId: '',
    AppSecurityGroupManagement: '',
    DomainSettings: '',
    DefaultSpaceSettings: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDomain';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DomainName":"","AuthMode":"","DefaultUserSettings":"","SubnetIds":"","VpcId":"","Tags":"","AppNetworkAccessType":"","HomeEfsFileSystemKmsKeyId":"","KmsKeyId":"","AppSecurityGroupManagement":"","DomainSettings":"","DefaultSpaceSettings":""}'
};

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=SageMaker.CreateDomain',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DomainName": "",\n  "AuthMode": "",\n  "DefaultUserSettings": "",\n  "SubnetIds": "",\n  "VpcId": "",\n  "Tags": "",\n  "AppNetworkAccessType": "",\n  "HomeEfsFileSystemKmsKeyId": "",\n  "KmsKeyId": "",\n  "AppSecurityGroupManagement": "",\n  "DomainSettings": "",\n  "DefaultSpaceSettings": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DomainName\": \"\",\n  \"AuthMode\": \"\",\n  \"DefaultUserSettings\": \"\",\n  \"SubnetIds\": \"\",\n  \"VpcId\": \"\",\n  \"Tags\": \"\",\n  \"AppNetworkAccessType\": \"\",\n  \"HomeEfsFileSystemKmsKeyId\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AppSecurityGroupManagement\": \"\",\n  \"DomainSettings\": \"\",\n  \"DefaultSpaceSettings\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDomain")
  .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({
  DomainName: '',
  AuthMode: '',
  DefaultUserSettings: '',
  SubnetIds: '',
  VpcId: '',
  Tags: '',
  AppNetworkAccessType: '',
  HomeEfsFileSystemKmsKeyId: '',
  KmsKeyId: '',
  AppSecurityGroupManagement: '',
  DomainSettings: '',
  DefaultSpaceSettings: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDomain',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    DomainName: '',
    AuthMode: '',
    DefaultUserSettings: '',
    SubnetIds: '',
    VpcId: '',
    Tags: '',
    AppNetworkAccessType: '',
    HomeEfsFileSystemKmsKeyId: '',
    KmsKeyId: '',
    AppSecurityGroupManagement: '',
    DomainSettings: '',
    DefaultSpaceSettings: ''
  },
  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=SageMaker.CreateDomain');

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

req.type('json');
req.send({
  DomainName: '',
  AuthMode: '',
  DefaultUserSettings: '',
  SubnetIds: '',
  VpcId: '',
  Tags: '',
  AppNetworkAccessType: '',
  HomeEfsFileSystemKmsKeyId: '',
  KmsKeyId: '',
  AppSecurityGroupManagement: '',
  DomainSettings: '',
  DefaultSpaceSettings: ''
});

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=SageMaker.CreateDomain',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    DomainName: '',
    AuthMode: '',
    DefaultUserSettings: '',
    SubnetIds: '',
    VpcId: '',
    Tags: '',
    AppNetworkAccessType: '',
    HomeEfsFileSystemKmsKeyId: '',
    KmsKeyId: '',
    AppSecurityGroupManagement: '',
    DomainSettings: '',
    DefaultSpaceSettings: ''
  }
};

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=SageMaker.CreateDomain';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DomainName":"","AuthMode":"","DefaultUserSettings":"","SubnetIds":"","VpcId":"","Tags":"","AppNetworkAccessType":"","HomeEfsFileSystemKmsKeyId":"","KmsKeyId":"","AppSecurityGroupManagement":"","DomainSettings":"","DefaultSpaceSettings":""}'
};

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 = @{ @"DomainName": @"",
                              @"AuthMode": @"",
                              @"DefaultUserSettings": @"",
                              @"SubnetIds": @"",
                              @"VpcId": @"",
                              @"Tags": @"",
                              @"AppNetworkAccessType": @"",
                              @"HomeEfsFileSystemKmsKeyId": @"",
                              @"KmsKeyId": @"",
                              @"AppSecurityGroupManagement": @"",
                              @"DomainSettings": @"",
                              @"DefaultSpaceSettings": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDomain"]
                                                       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=SageMaker.CreateDomain" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"DomainName\": \"\",\n  \"AuthMode\": \"\",\n  \"DefaultUserSettings\": \"\",\n  \"SubnetIds\": \"\",\n  \"VpcId\": \"\",\n  \"Tags\": \"\",\n  \"AppNetworkAccessType\": \"\",\n  \"HomeEfsFileSystemKmsKeyId\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AppSecurityGroupManagement\": \"\",\n  \"DomainSettings\": \"\",\n  \"DefaultSpaceSettings\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDomain",
  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([
    'DomainName' => '',
    'AuthMode' => '',
    'DefaultUserSettings' => '',
    'SubnetIds' => '',
    'VpcId' => '',
    'Tags' => '',
    'AppNetworkAccessType' => '',
    'HomeEfsFileSystemKmsKeyId' => '',
    'KmsKeyId' => '',
    'AppSecurityGroupManagement' => '',
    'DomainSettings' => '',
    'DefaultSpaceSettings' => ''
  ]),
  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=SageMaker.CreateDomain', [
  'body' => '{
  "DomainName": "",
  "AuthMode": "",
  "DefaultUserSettings": "",
  "SubnetIds": "",
  "VpcId": "",
  "Tags": "",
  "AppNetworkAccessType": "",
  "HomeEfsFileSystemKmsKeyId": "",
  "KmsKeyId": "",
  "AppSecurityGroupManagement": "",
  "DomainSettings": "",
  "DefaultSpaceSettings": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DomainName' => '',
  'AuthMode' => '',
  'DefaultUserSettings' => '',
  'SubnetIds' => '',
  'VpcId' => '',
  'Tags' => '',
  'AppNetworkAccessType' => '',
  'HomeEfsFileSystemKmsKeyId' => '',
  'KmsKeyId' => '',
  'AppSecurityGroupManagement' => '',
  'DomainSettings' => '',
  'DefaultSpaceSettings' => ''
]));

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

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

append(json_encode([
  'DomainName' => '',
  'AuthMode' => '',
  'DefaultUserSettings' => '',
  'SubnetIds' => '',
  'VpcId' => '',
  'Tags' => '',
  'AppNetworkAccessType' => '',
  'HomeEfsFileSystemKmsKeyId' => '',
  'KmsKeyId' => '',
  'AppSecurityGroupManagement' => '',
  'DomainSettings' => '',
  'DefaultSpaceSettings' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDomain');
$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=SageMaker.CreateDomain' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DomainName": "",
  "AuthMode": "",
  "DefaultUserSettings": "",
  "SubnetIds": "",
  "VpcId": "",
  "Tags": "",
  "AppNetworkAccessType": "",
  "HomeEfsFileSystemKmsKeyId": "",
  "KmsKeyId": "",
  "AppSecurityGroupManagement": "",
  "DomainSettings": "",
  "DefaultSpaceSettings": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDomain' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DomainName": "",
  "AuthMode": "",
  "DefaultUserSettings": "",
  "SubnetIds": "",
  "VpcId": "",
  "Tags": "",
  "AppNetworkAccessType": "",
  "HomeEfsFileSystemKmsKeyId": "",
  "KmsKeyId": "",
  "AppSecurityGroupManagement": "",
  "DomainSettings": "",
  "DefaultSpaceSettings": ""
}'

import http.client

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

payload = "{\n  \"DomainName\": \"\",\n  \"AuthMode\": \"\",\n  \"DefaultUserSettings\": \"\",\n  \"SubnetIds\": \"\",\n  \"VpcId\": \"\",\n  \"Tags\": \"\",\n  \"AppNetworkAccessType\": \"\",\n  \"HomeEfsFileSystemKmsKeyId\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AppSecurityGroupManagement\": \"\",\n  \"DomainSettings\": \"\",\n  \"DefaultSpaceSettings\": \"\"\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=SageMaker.CreateDomain"

payload = {
    "DomainName": "",
    "AuthMode": "",
    "DefaultUserSettings": "",
    "SubnetIds": "",
    "VpcId": "",
    "Tags": "",
    "AppNetworkAccessType": "",
    "HomeEfsFileSystemKmsKeyId": "",
    "KmsKeyId": "",
    "AppSecurityGroupManagement": "",
    "DomainSettings": "",
    "DefaultSpaceSettings": ""
}
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=SageMaker.CreateDomain"

payload <- "{\n  \"DomainName\": \"\",\n  \"AuthMode\": \"\",\n  \"DefaultUserSettings\": \"\",\n  \"SubnetIds\": \"\",\n  \"VpcId\": \"\",\n  \"Tags\": \"\",\n  \"AppNetworkAccessType\": \"\",\n  \"HomeEfsFileSystemKmsKeyId\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AppSecurityGroupManagement\": \"\",\n  \"DomainSettings\": \"\",\n  \"DefaultSpaceSettings\": \"\"\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=SageMaker.CreateDomain")

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  \"DomainName\": \"\",\n  \"AuthMode\": \"\",\n  \"DefaultUserSettings\": \"\",\n  \"SubnetIds\": \"\",\n  \"VpcId\": \"\",\n  \"Tags\": \"\",\n  \"AppNetworkAccessType\": \"\",\n  \"HomeEfsFileSystemKmsKeyId\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AppSecurityGroupManagement\": \"\",\n  \"DomainSettings\": \"\",\n  \"DefaultSpaceSettings\": \"\"\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  \"DomainName\": \"\",\n  \"AuthMode\": \"\",\n  \"DefaultUserSettings\": \"\",\n  \"SubnetIds\": \"\",\n  \"VpcId\": \"\",\n  \"Tags\": \"\",\n  \"AppNetworkAccessType\": \"\",\n  \"HomeEfsFileSystemKmsKeyId\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AppSecurityGroupManagement\": \"\",\n  \"DomainSettings\": \"\",\n  \"DefaultSpaceSettings\": \"\"\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=SageMaker.CreateDomain";

    let payload = json!({
        "DomainName": "",
        "AuthMode": "",
        "DefaultUserSettings": "",
        "SubnetIds": "",
        "VpcId": "",
        "Tags": "",
        "AppNetworkAccessType": "",
        "HomeEfsFileSystemKmsKeyId": "",
        "KmsKeyId": "",
        "AppSecurityGroupManagement": "",
        "DomainSettings": "",
        "DefaultSpaceSettings": ""
    });

    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);
}

echo '{
  "DomainName": "",
  "AuthMode": "",
  "DefaultUserSettings": "",
  "SubnetIds": "",
  "VpcId": "",
  "Tags": "",
  "AppNetworkAccessType": "",
  "HomeEfsFileSystemKmsKeyId": "",
  "KmsKeyId": "",
  "AppSecurityGroupManagement": "",
  "DomainSettings": "",
  "DefaultSpaceSettings": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDomain' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "DomainName": "",\n  "AuthMode": "",\n  "DefaultUserSettings": "",\n  "SubnetIds": "",\n  "VpcId": "",\n  "Tags": "",\n  "AppNetworkAccessType": "",\n  "HomeEfsFileSystemKmsKeyId": "",\n  "KmsKeyId": "",\n  "AppSecurityGroupManagement": "",\n  "DomainSettings": "",\n  "DefaultSpaceSettings": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateDomain'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "DomainName": "",
  "AuthMode": "",
  "DefaultUserSettings": "",
  "SubnetIds": "",
  "VpcId": "",
  "Tags": "",
  "AppNetworkAccessType": "",
  "HomeEfsFileSystemKmsKeyId": "",
  "KmsKeyId": "",
  "AppSecurityGroupManagement": "",
  "DomainSettings": "",
  "DefaultSpaceSettings": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

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

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  \"EdgeDeploymentPlanName\": \"\",\n  \"ModelConfigs\": \"\",\n  \"DeviceFleetName\": \"\",\n  \"Stages\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEdgeDeploymentPlan" {:headers {:x-amz-target ""}
                                                                                             :content-type :json
                                                                                             :form-params {:EdgeDeploymentPlanName ""
                                                                                                           :ModelConfigs ""
                                                                                                           :DeviceFleetName ""
                                                                                                           :Stages ""
                                                                                                           :Tags ""}})

require "http/client"

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

	payload := strings.NewReader("{\n  \"EdgeDeploymentPlanName\": \"\",\n  \"ModelConfigs\": \"\",\n  \"DeviceFleetName\": \"\",\n  \"Stages\": \"\",\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: 111

{
  "EdgeDeploymentPlanName": "",
  "ModelConfigs": "",
  "DeviceFleetName": "",
  "Stages": "",
  "Tags": ""
}

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

client.close();

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

const data = JSON.stringify({
  EdgeDeploymentPlanName: '',
  ModelConfigs: '',
  DeviceFleetName: '',
  Stages: '',
  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=SageMaker.CreateEdgeDeploymentPlan');
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=SageMaker.CreateEdgeDeploymentPlan',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    EdgeDeploymentPlanName: '',
    ModelConfigs: '',
    DeviceFleetName: '',
    Stages: '',
    Tags: ''
  }
};

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

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

const request = require('request');

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

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

req.type('json');
req.send({
  EdgeDeploymentPlanName: '',
  ModelConfigs: '',
  DeviceFleetName: '',
  Stages: '',
  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=SageMaker.CreateEdgeDeploymentPlan',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    EdgeDeploymentPlanName: '',
    ModelConfigs: '',
    DeviceFleetName: '',
    Stages: '',
    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=SageMaker.CreateEdgeDeploymentPlan';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EdgeDeploymentPlanName":"","ModelConfigs":"","DeviceFleetName":"","Stages":"","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 = @{ @"EdgeDeploymentPlanName": @"",
                              @"ModelConfigs": @"",
                              @"DeviceFleetName": @"",
                              @"Stages": @"",
                              @"Tags": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEdgeDeploymentPlan",
  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([
    'EdgeDeploymentPlanName' => '',
    'ModelConfigs' => '',
    'DeviceFleetName' => '',
    'Stages' => '',
    '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=SageMaker.CreateEdgeDeploymentPlan', [
  'body' => '{
  "EdgeDeploymentPlanName": "",
  "ModelConfigs": "",
  "DeviceFleetName": "",
  "Stages": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'EdgeDeploymentPlanName' => '',
  'ModelConfigs' => '',
  'DeviceFleetName' => '',
  'Stages' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'EdgeDeploymentPlanName' => '',
  'ModelConfigs' => '',
  'DeviceFleetName' => '',
  'Stages' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEdgeDeploymentPlan');
$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=SageMaker.CreateEdgeDeploymentPlan' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EdgeDeploymentPlanName": "",
  "ModelConfigs": "",
  "DeviceFleetName": "",
  "Stages": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEdgeDeploymentPlan' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EdgeDeploymentPlanName": "",
  "ModelConfigs": "",
  "DeviceFleetName": "",
  "Stages": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"EdgeDeploymentPlanName\": \"\",\n  \"ModelConfigs\": \"\",\n  \"DeviceFleetName\": \"\",\n  \"Stages\": \"\",\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=SageMaker.CreateEdgeDeploymentPlan"

payload = {
    "EdgeDeploymentPlanName": "",
    "ModelConfigs": "",
    "DeviceFleetName": "",
    "Stages": "",
    "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=SageMaker.CreateEdgeDeploymentPlan"

payload <- "{\n  \"EdgeDeploymentPlanName\": \"\",\n  \"ModelConfigs\": \"\",\n  \"DeviceFleetName\": \"\",\n  \"Stages\": \"\",\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=SageMaker.CreateEdgeDeploymentPlan")

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  \"EdgeDeploymentPlanName\": \"\",\n  \"ModelConfigs\": \"\",\n  \"DeviceFleetName\": \"\",\n  \"Stages\": \"\",\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  \"EdgeDeploymentPlanName\": \"\",\n  \"ModelConfigs\": \"\",\n  \"DeviceFleetName\": \"\",\n  \"Stages\": \"\",\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=SageMaker.CreateEdgeDeploymentPlan";

    let payload = json!({
        "EdgeDeploymentPlanName": "",
        "ModelConfigs": "",
        "DeviceFleetName": "",
        "Stages": "",
        "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);
}

echo '{
  "EdgeDeploymentPlanName": "",
  "ModelConfigs": "",
  "DeviceFleetName": "",
  "Stages": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEdgeDeploymentPlan' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "EdgeDeploymentPlanName": "",\n  "ModelConfigs": "",\n  "DeviceFleetName": "",\n  "Stages": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEdgeDeploymentPlan'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "EdgeDeploymentPlanName": "",
  "ModelConfigs": "",
  "DeviceFleetName": "",
  "Stages": "",
  "Tags": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEdgeDeploymentStage" {:headers {:x-amz-target ""}
                                                                                              :content-type :json
                                                                                              :form-params {:EdgeDeploymentPlanName ""
                                                                                                            :Stages ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEdgeDeploymentStage"

	payload := strings.NewReader("{\n  \"EdgeDeploymentPlanName\": \"\",\n  \"Stages\": \"\"\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: 50

{
  "EdgeDeploymentPlanName": "",
  "Stages": ""
}

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

client.close();

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

const data = JSON.stringify({
  EdgeDeploymentPlanName: '',
  Stages: ''
});

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=SageMaker.CreateEdgeDeploymentStage');
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=SageMaker.CreateEdgeDeploymentStage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {EdgeDeploymentPlanName: '', Stages: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  EdgeDeploymentPlanName: '',
  Stages: ''
});

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=SageMaker.CreateEdgeDeploymentStage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {EdgeDeploymentPlanName: '', Stages: ''}
};

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"EdgeDeploymentPlanName\": \"\",\n  \"Stages\": \"\"\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=SageMaker.CreateEdgeDeploymentStage"

payload = {
    "EdgeDeploymentPlanName": "",
    "Stages": ""
}
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=SageMaker.CreateEdgeDeploymentStage"

payload <- "{\n  \"EdgeDeploymentPlanName\": \"\",\n  \"Stages\": \"\"\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=SageMaker.CreateEdgeDeploymentStage")

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  \"EdgeDeploymentPlanName\": \"\",\n  \"Stages\": \"\"\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  \"EdgeDeploymentPlanName\": \"\",\n  \"Stages\": \"\"\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=SageMaker.CreateEdgeDeploymentStage";

    let payload = json!({
        "EdgeDeploymentPlanName": "",
        "Stages": ""
    });

    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);
}

echo '{
  "EdgeDeploymentPlanName": "",
  "Stages": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEdgeDeploymentStage' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

CURL *hnd = curl_easy_init();

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

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  \"EdgePackagingJobName\": \"\",\n  \"CompilationJobName\": \"\",\n  \"ModelName\": \"\",\n  \"ModelVersion\": \"\",\n  \"RoleArn\": \"\",\n  \"OutputConfig\": \"\",\n  \"ResourceKey\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEdgePackagingJob" {:headers {:x-amz-target ""}
                                                                                           :content-type :json
                                                                                           :form-params {:EdgePackagingJobName ""
                                                                                                         :CompilationJobName ""
                                                                                                         :ModelName ""
                                                                                                         :ModelVersion ""
                                                                                                         :RoleArn ""
                                                                                                         :OutputConfig ""
                                                                                                         :ResourceKey ""
                                                                                                         :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEdgePackagingJob"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"EdgePackagingJobName\": \"\",\n  \"CompilationJobName\": \"\",\n  \"ModelName\": \"\",\n  \"ModelVersion\": \"\",\n  \"RoleArn\": \"\",\n  \"OutputConfig\": \"\",\n  \"ResourceKey\": \"\",\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=SageMaker.CreateEdgePackagingJob"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"EdgePackagingJobName\": \"\",\n  \"CompilationJobName\": \"\",\n  \"ModelName\": \"\",\n  \"ModelVersion\": \"\",\n  \"RoleArn\": \"\",\n  \"OutputConfig\": \"\",\n  \"ResourceKey\": \"\",\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=SageMaker.CreateEdgePackagingJob");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"EdgePackagingJobName\": \"\",\n  \"CompilationJobName\": \"\",\n  \"ModelName\": \"\",\n  \"ModelVersion\": \"\",\n  \"RoleArn\": \"\",\n  \"OutputConfig\": \"\",\n  \"ResourceKey\": \"\",\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=SageMaker.CreateEdgePackagingJob"

	payload := strings.NewReader("{\n  \"EdgePackagingJobName\": \"\",\n  \"CompilationJobName\": \"\",\n  \"ModelName\": \"\",\n  \"ModelVersion\": \"\",\n  \"RoleArn\": \"\",\n  \"OutputConfig\": \"\",\n  \"ResourceKey\": \"\",\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: 175

{
  "EdgePackagingJobName": "",
  "CompilationJobName": "",
  "ModelName": "",
  "ModelVersion": "",
  "RoleArn": "",
  "OutputConfig": "",
  "ResourceKey": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEdgePackagingJob")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"EdgePackagingJobName\": \"\",\n  \"CompilationJobName\": \"\",\n  \"ModelName\": \"\",\n  \"ModelVersion\": \"\",\n  \"RoleArn\": \"\",\n  \"OutputConfig\": \"\",\n  \"ResourceKey\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

const data = JSON.stringify({
  EdgePackagingJobName: '',
  CompilationJobName: '',
  ModelName: '',
  ModelVersion: '',
  RoleArn: '',
  OutputConfig: '',
  ResourceKey: '',
  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=SageMaker.CreateEdgePackagingJob');
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=SageMaker.CreateEdgePackagingJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    EdgePackagingJobName: '',
    CompilationJobName: '',
    ModelName: '',
    ModelVersion: '',
    RoleArn: '',
    OutputConfig: '',
    ResourceKey: '',
    Tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEdgePackagingJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EdgePackagingJobName":"","CompilationJobName":"","ModelName":"","ModelVersion":"","RoleArn":"","OutputConfig":"","ResourceKey":"","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=SageMaker.CreateEdgePackagingJob',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "EdgePackagingJobName": "",\n  "CompilationJobName": "",\n  "ModelName": "",\n  "ModelVersion": "",\n  "RoleArn": "",\n  "OutputConfig": "",\n  "ResourceKey": "",\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  \"EdgePackagingJobName\": \"\",\n  \"CompilationJobName\": \"\",\n  \"ModelName\": \"\",\n  \"ModelVersion\": \"\",\n  \"RoleArn\": \"\",\n  \"OutputConfig\": \"\",\n  \"ResourceKey\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEdgePackagingJob")
  .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({
  EdgePackagingJobName: '',
  CompilationJobName: '',
  ModelName: '',
  ModelVersion: '',
  RoleArn: '',
  OutputConfig: '',
  ResourceKey: '',
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEdgePackagingJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    EdgePackagingJobName: '',
    CompilationJobName: '',
    ModelName: '',
    ModelVersion: '',
    RoleArn: '',
    OutputConfig: '',
    ResourceKey: '',
    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=SageMaker.CreateEdgePackagingJob');

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

req.type('json');
req.send({
  EdgePackagingJobName: '',
  CompilationJobName: '',
  ModelName: '',
  ModelVersion: '',
  RoleArn: '',
  OutputConfig: '',
  ResourceKey: '',
  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=SageMaker.CreateEdgePackagingJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    EdgePackagingJobName: '',
    CompilationJobName: '',
    ModelName: '',
    ModelVersion: '',
    RoleArn: '',
    OutputConfig: '',
    ResourceKey: '',
    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=SageMaker.CreateEdgePackagingJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EdgePackagingJobName":"","CompilationJobName":"","ModelName":"","ModelVersion":"","RoleArn":"","OutputConfig":"","ResourceKey":"","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 = @{ @"EdgePackagingJobName": @"",
                              @"CompilationJobName": @"",
                              @"ModelName": @"",
                              @"ModelVersion": @"",
                              @"RoleArn": @"",
                              @"OutputConfig": @"",
                              @"ResourceKey": @"",
                              @"Tags": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEdgePackagingJob",
  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([
    'EdgePackagingJobName' => '',
    'CompilationJobName' => '',
    'ModelName' => '',
    'ModelVersion' => '',
    'RoleArn' => '',
    'OutputConfig' => '',
    'ResourceKey' => '',
    '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=SageMaker.CreateEdgePackagingJob', [
  'body' => '{
  "EdgePackagingJobName": "",
  "CompilationJobName": "",
  "ModelName": "",
  "ModelVersion": "",
  "RoleArn": "",
  "OutputConfig": "",
  "ResourceKey": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'EdgePackagingJobName' => '',
  'CompilationJobName' => '',
  'ModelName' => '',
  'ModelVersion' => '',
  'RoleArn' => '',
  'OutputConfig' => '',
  'ResourceKey' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'EdgePackagingJobName' => '',
  'CompilationJobName' => '',
  'ModelName' => '',
  'ModelVersion' => '',
  'RoleArn' => '',
  'OutputConfig' => '',
  'ResourceKey' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEdgePackagingJob');
$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=SageMaker.CreateEdgePackagingJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EdgePackagingJobName": "",
  "CompilationJobName": "",
  "ModelName": "",
  "ModelVersion": "",
  "RoleArn": "",
  "OutputConfig": "",
  "ResourceKey": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEdgePackagingJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EdgePackagingJobName": "",
  "CompilationJobName": "",
  "ModelName": "",
  "ModelVersion": "",
  "RoleArn": "",
  "OutputConfig": "",
  "ResourceKey": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"EdgePackagingJobName\": \"\",\n  \"CompilationJobName\": \"\",\n  \"ModelName\": \"\",\n  \"ModelVersion\": \"\",\n  \"RoleArn\": \"\",\n  \"OutputConfig\": \"\",\n  \"ResourceKey\": \"\",\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=SageMaker.CreateEdgePackagingJob"

payload = {
    "EdgePackagingJobName": "",
    "CompilationJobName": "",
    "ModelName": "",
    "ModelVersion": "",
    "RoleArn": "",
    "OutputConfig": "",
    "ResourceKey": "",
    "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=SageMaker.CreateEdgePackagingJob"

payload <- "{\n  \"EdgePackagingJobName\": \"\",\n  \"CompilationJobName\": \"\",\n  \"ModelName\": \"\",\n  \"ModelVersion\": \"\",\n  \"RoleArn\": \"\",\n  \"OutputConfig\": \"\",\n  \"ResourceKey\": \"\",\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=SageMaker.CreateEdgePackagingJob")

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  \"EdgePackagingJobName\": \"\",\n  \"CompilationJobName\": \"\",\n  \"ModelName\": \"\",\n  \"ModelVersion\": \"\",\n  \"RoleArn\": \"\",\n  \"OutputConfig\": \"\",\n  \"ResourceKey\": \"\",\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  \"EdgePackagingJobName\": \"\",\n  \"CompilationJobName\": \"\",\n  \"ModelName\": \"\",\n  \"ModelVersion\": \"\",\n  \"RoleArn\": \"\",\n  \"OutputConfig\": \"\",\n  \"ResourceKey\": \"\",\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=SageMaker.CreateEdgePackagingJob";

    let payload = json!({
        "EdgePackagingJobName": "",
        "CompilationJobName": "",
        "ModelName": "",
        "ModelVersion": "",
        "RoleArn": "",
        "OutputConfig": "",
        "ResourceKey": "",
        "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);
}

echo '{
  "EdgePackagingJobName": "",
  "CompilationJobName": "",
  "ModelName": "",
  "ModelVersion": "",
  "RoleArn": "",
  "OutputConfig": "",
  "ResourceKey": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEdgePackagingJob' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "EdgePackagingJobName": "",\n  "CompilationJobName": "",\n  "ModelName": "",\n  "ModelVersion": "",\n  "RoleArn": "",\n  "OutputConfig": "",\n  "ResourceKey": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEdgePackagingJob'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "EdgePackagingJobName": "",
  "CompilationJobName": "",
  "ModelName": "",
  "ModelVersion": "",
  "RoleArn": "",
  "OutputConfig": "",
  "ResourceKey": "",
  "Tags": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

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

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  \"EndpointName\": \"\",\n  \"EndpointConfigName\": \"\",\n  \"DeploymentConfig\": {\n    \"BlueGreenUpdatePolicy\": \"\",\n    \"AutoRollbackConfiguration\": \"\"\n  },\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEndpoint" {:headers {:x-amz-target ""}
                                                                                   :content-type :json
                                                                                   :form-params {:EndpointName ""
                                                                                                 :EndpointConfigName ""
                                                                                                 :DeploymentConfig {:BlueGreenUpdatePolicy ""
                                                                                                                    :AutoRollbackConfiguration ""}
                                                                                                 :Tags ""}})

require "http/client"

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

	payload := strings.NewReader("{\n  \"EndpointName\": \"\",\n  \"EndpointConfigName\": \"\",\n  \"DeploymentConfig\": {\n    \"BlueGreenUpdatePolicy\": \"\",\n    \"AutoRollbackConfiguration\": \"\"\n  },\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: 164

{
  "EndpointName": "",
  "EndpointConfigName": "",
  "DeploymentConfig": {
    "BlueGreenUpdatePolicy": "",
    "AutoRollbackConfiguration": ""
  },
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEndpoint")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"EndpointName\": \"\",\n  \"EndpointConfigName\": \"\",\n  \"DeploymentConfig\": {\n    \"BlueGreenUpdatePolicy\": \"\",\n    \"AutoRollbackConfiguration\": \"\"\n  },\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

const data = JSON.stringify({
  EndpointName: '',
  EndpointConfigName: '',
  DeploymentConfig: {
    BlueGreenUpdatePolicy: '',
    AutoRollbackConfiguration: ''
  },
  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=SageMaker.CreateEndpoint');
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=SageMaker.CreateEndpoint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    EndpointName: '',
    EndpointConfigName: '',
    DeploymentConfig: {BlueGreenUpdatePolicy: '', AutoRollbackConfiguration: ''},
    Tags: ''
  }
};

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

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEndpoint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    EndpointName: '',
    EndpointConfigName: '',
    DeploymentConfig: {BlueGreenUpdatePolicy: '', AutoRollbackConfiguration: ''},
    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=SageMaker.CreateEndpoint');

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

req.type('json');
req.send({
  EndpointName: '',
  EndpointConfigName: '',
  DeploymentConfig: {
    BlueGreenUpdatePolicy: '',
    AutoRollbackConfiguration: ''
  },
  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=SageMaker.CreateEndpoint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    EndpointName: '',
    EndpointConfigName: '',
    DeploymentConfig: {BlueGreenUpdatePolicy: '', AutoRollbackConfiguration: ''},
    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=SageMaker.CreateEndpoint';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EndpointName":"","EndpointConfigName":"","DeploymentConfig":{"BlueGreenUpdatePolicy":"","AutoRollbackConfiguration":""},"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 = @{ @"EndpointName": @"",
                              @"EndpointConfigName": @"",
                              @"DeploymentConfig": @{ @"BlueGreenUpdatePolicy": @"", @"AutoRollbackConfiguration": @"" },
                              @"Tags": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEndpoint",
  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([
    'EndpointName' => '',
    'EndpointConfigName' => '',
    'DeploymentConfig' => [
        'BlueGreenUpdatePolicy' => '',
        'AutoRollbackConfiguration' => ''
    ],
    '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=SageMaker.CreateEndpoint', [
  'body' => '{
  "EndpointName": "",
  "EndpointConfigName": "",
  "DeploymentConfig": {
    "BlueGreenUpdatePolicy": "",
    "AutoRollbackConfiguration": ""
  },
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'EndpointName' => '',
  'EndpointConfigName' => '',
  'DeploymentConfig' => [
    'BlueGreenUpdatePolicy' => '',
    'AutoRollbackConfiguration' => ''
  ],
  'Tags' => ''
]));

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

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

append(json_encode([
  'EndpointName' => '',
  'EndpointConfigName' => '',
  'DeploymentConfig' => [
    'BlueGreenUpdatePolicy' => '',
    'AutoRollbackConfiguration' => ''
  ],
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEndpoint');
$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=SageMaker.CreateEndpoint' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EndpointName": "",
  "EndpointConfigName": "",
  "DeploymentConfig": {
    "BlueGreenUpdatePolicy": "",
    "AutoRollbackConfiguration": ""
  },
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEndpoint' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EndpointName": "",
  "EndpointConfigName": "",
  "DeploymentConfig": {
    "BlueGreenUpdatePolicy": "",
    "AutoRollbackConfiguration": ""
  },
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"EndpointName\": \"\",\n  \"EndpointConfigName\": \"\",\n  \"DeploymentConfig\": {\n    \"BlueGreenUpdatePolicy\": \"\",\n    \"AutoRollbackConfiguration\": \"\"\n  },\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=SageMaker.CreateEndpoint"

payload = {
    "EndpointName": "",
    "EndpointConfigName": "",
    "DeploymentConfig": {
        "BlueGreenUpdatePolicy": "",
        "AutoRollbackConfiguration": ""
    },
    "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=SageMaker.CreateEndpoint"

payload <- "{\n  \"EndpointName\": \"\",\n  \"EndpointConfigName\": \"\",\n  \"DeploymentConfig\": {\n    \"BlueGreenUpdatePolicy\": \"\",\n    \"AutoRollbackConfiguration\": \"\"\n  },\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=SageMaker.CreateEndpoint")

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  \"EndpointName\": \"\",\n  \"EndpointConfigName\": \"\",\n  \"DeploymentConfig\": {\n    \"BlueGreenUpdatePolicy\": \"\",\n    \"AutoRollbackConfiguration\": \"\"\n  },\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  \"EndpointName\": \"\",\n  \"EndpointConfigName\": \"\",\n  \"DeploymentConfig\": {\n    \"BlueGreenUpdatePolicy\": \"\",\n    \"AutoRollbackConfiguration\": \"\"\n  },\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=SageMaker.CreateEndpoint";

    let payload = json!({
        "EndpointName": "",
        "EndpointConfigName": "",
        "DeploymentConfig": json!({
            "BlueGreenUpdatePolicy": "",
            "AutoRollbackConfiguration": ""
        }),
        "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);
}

echo '{
  "EndpointName": "",
  "EndpointConfigName": "",
  "DeploymentConfig": {
    "BlueGreenUpdatePolicy": "",
    "AutoRollbackConfiguration": ""
  },
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEndpoint' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "EndpointName": "",\n  "EndpointConfigName": "",\n  "DeploymentConfig": {\n    "BlueGreenUpdatePolicy": "",\n    "AutoRollbackConfiguration": ""\n  },\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEndpoint'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "EndpointName": "",
  "EndpointConfigName": "",
  "DeploymentConfig": [
    "BlueGreenUpdatePolicy": "",
    "AutoRollbackConfiguration": ""
  ],
  "Tags": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

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

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  \"EndpointConfigName\": \"\",\n  \"ProductionVariants\": \"\",\n  \"DataCaptureConfig\": {\n    \"EnableCapture\": \"\",\n    \"InitialSamplingPercentage\": \"\",\n    \"DestinationS3Uri\": \"\",\n    \"KmsKeyId\": \"\",\n    \"CaptureOptions\": \"\",\n    \"CaptureContentTypeHeader\": \"\"\n  },\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AsyncInferenceConfig\": \"\",\n  \"ExplainerConfig\": \"\",\n  \"ShadowProductionVariants\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEndpointConfig" {:headers {:x-amz-target ""}
                                                                                         :content-type :json
                                                                                         :form-params {:EndpointConfigName ""
                                                                                                       :ProductionVariants ""
                                                                                                       :DataCaptureConfig {:EnableCapture ""
                                                                                                                           :InitialSamplingPercentage ""
                                                                                                                           :DestinationS3Uri ""
                                                                                                                           :KmsKeyId ""
                                                                                                                           :CaptureOptions ""
                                                                                                                           :CaptureContentTypeHeader ""}
                                                                                                       :Tags ""
                                                                                                       :KmsKeyId ""
                                                                                                       :AsyncInferenceConfig ""
                                                                                                       :ExplainerConfig ""
                                                                                                       :ShadowProductionVariants ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEndpointConfig"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"EndpointConfigName\": \"\",\n  \"ProductionVariants\": \"\",\n  \"DataCaptureConfig\": {\n    \"EnableCapture\": \"\",\n    \"InitialSamplingPercentage\": \"\",\n    \"DestinationS3Uri\": \"\",\n    \"KmsKeyId\": \"\",\n    \"CaptureOptions\": \"\",\n    \"CaptureContentTypeHeader\": \"\"\n  },\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AsyncInferenceConfig\": \"\",\n  \"ExplainerConfig\": \"\",\n  \"ShadowProductionVariants\": \"\"\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=SageMaker.CreateEndpointConfig"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"EndpointConfigName\": \"\",\n  \"ProductionVariants\": \"\",\n  \"DataCaptureConfig\": {\n    \"EnableCapture\": \"\",\n    \"InitialSamplingPercentage\": \"\",\n    \"DestinationS3Uri\": \"\",\n    \"KmsKeyId\": \"\",\n    \"CaptureOptions\": \"\",\n    \"CaptureContentTypeHeader\": \"\"\n  },\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AsyncInferenceConfig\": \"\",\n  \"ExplainerConfig\": \"\",\n  \"ShadowProductionVariants\": \"\"\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=SageMaker.CreateEndpointConfig");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"EndpointConfigName\": \"\",\n  \"ProductionVariants\": \"\",\n  \"DataCaptureConfig\": {\n    \"EnableCapture\": \"\",\n    \"InitialSamplingPercentage\": \"\",\n    \"DestinationS3Uri\": \"\",\n    \"KmsKeyId\": \"\",\n    \"CaptureOptions\": \"\",\n    \"CaptureContentTypeHeader\": \"\"\n  },\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AsyncInferenceConfig\": \"\",\n  \"ExplainerConfig\": \"\",\n  \"ShadowProductionVariants\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEndpointConfig"

	payload := strings.NewReader("{\n  \"EndpointConfigName\": \"\",\n  \"ProductionVariants\": \"\",\n  \"DataCaptureConfig\": {\n    \"EnableCapture\": \"\",\n    \"InitialSamplingPercentage\": \"\",\n    \"DestinationS3Uri\": \"\",\n    \"KmsKeyId\": \"\",\n    \"CaptureOptions\": \"\",\n    \"CaptureContentTypeHeader\": \"\"\n  },\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AsyncInferenceConfig\": \"\",\n  \"ExplainerConfig\": \"\",\n  \"ShadowProductionVariants\": \"\"\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: 380

{
  "EndpointConfigName": "",
  "ProductionVariants": "",
  "DataCaptureConfig": {
    "EnableCapture": "",
    "InitialSamplingPercentage": "",
    "DestinationS3Uri": "",
    "KmsKeyId": "",
    "CaptureOptions": "",
    "CaptureContentTypeHeader": ""
  },
  "Tags": "",
  "KmsKeyId": "",
  "AsyncInferenceConfig": "",
  "ExplainerConfig": "",
  "ShadowProductionVariants": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEndpointConfig")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"EndpointConfigName\": \"\",\n  \"ProductionVariants\": \"\",\n  \"DataCaptureConfig\": {\n    \"EnableCapture\": \"\",\n    \"InitialSamplingPercentage\": \"\",\n    \"DestinationS3Uri\": \"\",\n    \"KmsKeyId\": \"\",\n    \"CaptureOptions\": \"\",\n    \"CaptureContentTypeHeader\": \"\"\n  },\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AsyncInferenceConfig\": \"\",\n  \"ExplainerConfig\": \"\",\n  \"ShadowProductionVariants\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEndpointConfig"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"EndpointConfigName\": \"\",\n  \"ProductionVariants\": \"\",\n  \"DataCaptureConfig\": {\n    \"EnableCapture\": \"\",\n    \"InitialSamplingPercentage\": \"\",\n    \"DestinationS3Uri\": \"\",\n    \"KmsKeyId\": \"\",\n    \"CaptureOptions\": \"\",\n    \"CaptureContentTypeHeader\": \"\"\n  },\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AsyncInferenceConfig\": \"\",\n  \"ExplainerConfig\": \"\",\n  \"ShadowProductionVariants\": \"\"\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  \"EndpointConfigName\": \"\",\n  \"ProductionVariants\": \"\",\n  \"DataCaptureConfig\": {\n    \"EnableCapture\": \"\",\n    \"InitialSamplingPercentage\": \"\",\n    \"DestinationS3Uri\": \"\",\n    \"KmsKeyId\": \"\",\n    \"CaptureOptions\": \"\",\n    \"CaptureContentTypeHeader\": \"\"\n  },\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AsyncInferenceConfig\": \"\",\n  \"ExplainerConfig\": \"\",\n  \"ShadowProductionVariants\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEndpointConfig")
  .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=SageMaker.CreateEndpointConfig")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"EndpointConfigName\": \"\",\n  \"ProductionVariants\": \"\",\n  \"DataCaptureConfig\": {\n    \"EnableCapture\": \"\",\n    \"InitialSamplingPercentage\": \"\",\n    \"DestinationS3Uri\": \"\",\n    \"KmsKeyId\": \"\",\n    \"CaptureOptions\": \"\",\n    \"CaptureContentTypeHeader\": \"\"\n  },\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AsyncInferenceConfig\": \"\",\n  \"ExplainerConfig\": \"\",\n  \"ShadowProductionVariants\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  EndpointConfigName: '',
  ProductionVariants: '',
  DataCaptureConfig: {
    EnableCapture: '',
    InitialSamplingPercentage: '',
    DestinationS3Uri: '',
    KmsKeyId: '',
    CaptureOptions: '',
    CaptureContentTypeHeader: ''
  },
  Tags: '',
  KmsKeyId: '',
  AsyncInferenceConfig: '',
  ExplainerConfig: '',
  ShadowProductionVariants: ''
});

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=SageMaker.CreateEndpointConfig');
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=SageMaker.CreateEndpointConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    EndpointConfigName: '',
    ProductionVariants: '',
    DataCaptureConfig: {
      EnableCapture: '',
      InitialSamplingPercentage: '',
      DestinationS3Uri: '',
      KmsKeyId: '',
      CaptureOptions: '',
      CaptureContentTypeHeader: ''
    },
    Tags: '',
    KmsKeyId: '',
    AsyncInferenceConfig: '',
    ExplainerConfig: '',
    ShadowProductionVariants: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEndpointConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EndpointConfigName":"","ProductionVariants":"","DataCaptureConfig":{"EnableCapture":"","InitialSamplingPercentage":"","DestinationS3Uri":"","KmsKeyId":"","CaptureOptions":"","CaptureContentTypeHeader":""},"Tags":"","KmsKeyId":"","AsyncInferenceConfig":"","ExplainerConfig":"","ShadowProductionVariants":""}'
};

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=SageMaker.CreateEndpointConfig',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "EndpointConfigName": "",\n  "ProductionVariants": "",\n  "DataCaptureConfig": {\n    "EnableCapture": "",\n    "InitialSamplingPercentage": "",\n    "DestinationS3Uri": "",\n    "KmsKeyId": "",\n    "CaptureOptions": "",\n    "CaptureContentTypeHeader": ""\n  },\n  "Tags": "",\n  "KmsKeyId": "",\n  "AsyncInferenceConfig": "",\n  "ExplainerConfig": "",\n  "ShadowProductionVariants": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"EndpointConfigName\": \"\",\n  \"ProductionVariants\": \"\",\n  \"DataCaptureConfig\": {\n    \"EnableCapture\": \"\",\n    \"InitialSamplingPercentage\": \"\",\n    \"DestinationS3Uri\": \"\",\n    \"KmsKeyId\": \"\",\n    \"CaptureOptions\": \"\",\n    \"CaptureContentTypeHeader\": \"\"\n  },\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AsyncInferenceConfig\": \"\",\n  \"ExplainerConfig\": \"\",\n  \"ShadowProductionVariants\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEndpointConfig")
  .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({
  EndpointConfigName: '',
  ProductionVariants: '',
  DataCaptureConfig: {
    EnableCapture: '',
    InitialSamplingPercentage: '',
    DestinationS3Uri: '',
    KmsKeyId: '',
    CaptureOptions: '',
    CaptureContentTypeHeader: ''
  },
  Tags: '',
  KmsKeyId: '',
  AsyncInferenceConfig: '',
  ExplainerConfig: '',
  ShadowProductionVariants: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEndpointConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    EndpointConfigName: '',
    ProductionVariants: '',
    DataCaptureConfig: {
      EnableCapture: '',
      InitialSamplingPercentage: '',
      DestinationS3Uri: '',
      KmsKeyId: '',
      CaptureOptions: '',
      CaptureContentTypeHeader: ''
    },
    Tags: '',
    KmsKeyId: '',
    AsyncInferenceConfig: '',
    ExplainerConfig: '',
    ShadowProductionVariants: ''
  },
  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=SageMaker.CreateEndpointConfig');

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

req.type('json');
req.send({
  EndpointConfigName: '',
  ProductionVariants: '',
  DataCaptureConfig: {
    EnableCapture: '',
    InitialSamplingPercentage: '',
    DestinationS3Uri: '',
    KmsKeyId: '',
    CaptureOptions: '',
    CaptureContentTypeHeader: ''
  },
  Tags: '',
  KmsKeyId: '',
  AsyncInferenceConfig: '',
  ExplainerConfig: '',
  ShadowProductionVariants: ''
});

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=SageMaker.CreateEndpointConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    EndpointConfigName: '',
    ProductionVariants: '',
    DataCaptureConfig: {
      EnableCapture: '',
      InitialSamplingPercentage: '',
      DestinationS3Uri: '',
      KmsKeyId: '',
      CaptureOptions: '',
      CaptureContentTypeHeader: ''
    },
    Tags: '',
    KmsKeyId: '',
    AsyncInferenceConfig: '',
    ExplainerConfig: '',
    ShadowProductionVariants: ''
  }
};

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=SageMaker.CreateEndpointConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EndpointConfigName":"","ProductionVariants":"","DataCaptureConfig":{"EnableCapture":"","InitialSamplingPercentage":"","DestinationS3Uri":"","KmsKeyId":"","CaptureOptions":"","CaptureContentTypeHeader":""},"Tags":"","KmsKeyId":"","AsyncInferenceConfig":"","ExplainerConfig":"","ShadowProductionVariants":""}'
};

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 = @{ @"EndpointConfigName": @"",
                              @"ProductionVariants": @"",
                              @"DataCaptureConfig": @{ @"EnableCapture": @"", @"InitialSamplingPercentage": @"", @"DestinationS3Uri": @"", @"KmsKeyId": @"", @"CaptureOptions": @"", @"CaptureContentTypeHeader": @"" },
                              @"Tags": @"",
                              @"KmsKeyId": @"",
                              @"AsyncInferenceConfig": @"",
                              @"ExplainerConfig": @"",
                              @"ShadowProductionVariants": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEndpointConfig"]
                                                       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=SageMaker.CreateEndpointConfig" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"EndpointConfigName\": \"\",\n  \"ProductionVariants\": \"\",\n  \"DataCaptureConfig\": {\n    \"EnableCapture\": \"\",\n    \"InitialSamplingPercentage\": \"\",\n    \"DestinationS3Uri\": \"\",\n    \"KmsKeyId\": \"\",\n    \"CaptureOptions\": \"\",\n    \"CaptureContentTypeHeader\": \"\"\n  },\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AsyncInferenceConfig\": \"\",\n  \"ExplainerConfig\": \"\",\n  \"ShadowProductionVariants\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEndpointConfig",
  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([
    'EndpointConfigName' => '',
    'ProductionVariants' => '',
    'DataCaptureConfig' => [
        'EnableCapture' => '',
        'InitialSamplingPercentage' => '',
        'DestinationS3Uri' => '',
        'KmsKeyId' => '',
        'CaptureOptions' => '',
        'CaptureContentTypeHeader' => ''
    ],
    'Tags' => '',
    'KmsKeyId' => '',
    'AsyncInferenceConfig' => '',
    'ExplainerConfig' => '',
    'ShadowProductionVariants' => ''
  ]),
  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=SageMaker.CreateEndpointConfig', [
  'body' => '{
  "EndpointConfigName": "",
  "ProductionVariants": "",
  "DataCaptureConfig": {
    "EnableCapture": "",
    "InitialSamplingPercentage": "",
    "DestinationS3Uri": "",
    "KmsKeyId": "",
    "CaptureOptions": "",
    "CaptureContentTypeHeader": ""
  },
  "Tags": "",
  "KmsKeyId": "",
  "AsyncInferenceConfig": "",
  "ExplainerConfig": "",
  "ShadowProductionVariants": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'EndpointConfigName' => '',
  'ProductionVariants' => '',
  'DataCaptureConfig' => [
    'EnableCapture' => '',
    'InitialSamplingPercentage' => '',
    'DestinationS3Uri' => '',
    'KmsKeyId' => '',
    'CaptureOptions' => '',
    'CaptureContentTypeHeader' => ''
  ],
  'Tags' => '',
  'KmsKeyId' => '',
  'AsyncInferenceConfig' => '',
  'ExplainerConfig' => '',
  'ShadowProductionVariants' => ''
]));

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

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

append(json_encode([
  'EndpointConfigName' => '',
  'ProductionVariants' => '',
  'DataCaptureConfig' => [
    'EnableCapture' => '',
    'InitialSamplingPercentage' => '',
    'DestinationS3Uri' => '',
    'KmsKeyId' => '',
    'CaptureOptions' => '',
    'CaptureContentTypeHeader' => ''
  ],
  'Tags' => '',
  'KmsKeyId' => '',
  'AsyncInferenceConfig' => '',
  'ExplainerConfig' => '',
  'ShadowProductionVariants' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEndpointConfig');
$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=SageMaker.CreateEndpointConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EndpointConfigName": "",
  "ProductionVariants": "",
  "DataCaptureConfig": {
    "EnableCapture": "",
    "InitialSamplingPercentage": "",
    "DestinationS3Uri": "",
    "KmsKeyId": "",
    "CaptureOptions": "",
    "CaptureContentTypeHeader": ""
  },
  "Tags": "",
  "KmsKeyId": "",
  "AsyncInferenceConfig": "",
  "ExplainerConfig": "",
  "ShadowProductionVariants": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEndpointConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EndpointConfigName": "",
  "ProductionVariants": "",
  "DataCaptureConfig": {
    "EnableCapture": "",
    "InitialSamplingPercentage": "",
    "DestinationS3Uri": "",
    "KmsKeyId": "",
    "CaptureOptions": "",
    "CaptureContentTypeHeader": ""
  },
  "Tags": "",
  "KmsKeyId": "",
  "AsyncInferenceConfig": "",
  "ExplainerConfig": "",
  "ShadowProductionVariants": ""
}'

import http.client

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

payload = "{\n  \"EndpointConfigName\": \"\",\n  \"ProductionVariants\": \"\",\n  \"DataCaptureConfig\": {\n    \"EnableCapture\": \"\",\n    \"InitialSamplingPercentage\": \"\",\n    \"DestinationS3Uri\": \"\",\n    \"KmsKeyId\": \"\",\n    \"CaptureOptions\": \"\",\n    \"CaptureContentTypeHeader\": \"\"\n  },\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AsyncInferenceConfig\": \"\",\n  \"ExplainerConfig\": \"\",\n  \"ShadowProductionVariants\": \"\"\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=SageMaker.CreateEndpointConfig"

payload = {
    "EndpointConfigName": "",
    "ProductionVariants": "",
    "DataCaptureConfig": {
        "EnableCapture": "",
        "InitialSamplingPercentage": "",
        "DestinationS3Uri": "",
        "KmsKeyId": "",
        "CaptureOptions": "",
        "CaptureContentTypeHeader": ""
    },
    "Tags": "",
    "KmsKeyId": "",
    "AsyncInferenceConfig": "",
    "ExplainerConfig": "",
    "ShadowProductionVariants": ""
}
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=SageMaker.CreateEndpointConfig"

payload <- "{\n  \"EndpointConfigName\": \"\",\n  \"ProductionVariants\": \"\",\n  \"DataCaptureConfig\": {\n    \"EnableCapture\": \"\",\n    \"InitialSamplingPercentage\": \"\",\n    \"DestinationS3Uri\": \"\",\n    \"KmsKeyId\": \"\",\n    \"CaptureOptions\": \"\",\n    \"CaptureContentTypeHeader\": \"\"\n  },\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AsyncInferenceConfig\": \"\",\n  \"ExplainerConfig\": \"\",\n  \"ShadowProductionVariants\": \"\"\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=SageMaker.CreateEndpointConfig")

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  \"EndpointConfigName\": \"\",\n  \"ProductionVariants\": \"\",\n  \"DataCaptureConfig\": {\n    \"EnableCapture\": \"\",\n    \"InitialSamplingPercentage\": \"\",\n    \"DestinationS3Uri\": \"\",\n    \"KmsKeyId\": \"\",\n    \"CaptureOptions\": \"\",\n    \"CaptureContentTypeHeader\": \"\"\n  },\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AsyncInferenceConfig\": \"\",\n  \"ExplainerConfig\": \"\",\n  \"ShadowProductionVariants\": \"\"\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  \"EndpointConfigName\": \"\",\n  \"ProductionVariants\": \"\",\n  \"DataCaptureConfig\": {\n    \"EnableCapture\": \"\",\n    \"InitialSamplingPercentage\": \"\",\n    \"DestinationS3Uri\": \"\",\n    \"KmsKeyId\": \"\",\n    \"CaptureOptions\": \"\",\n    \"CaptureContentTypeHeader\": \"\"\n  },\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"AsyncInferenceConfig\": \"\",\n  \"ExplainerConfig\": \"\",\n  \"ShadowProductionVariants\": \"\"\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=SageMaker.CreateEndpointConfig";

    let payload = json!({
        "EndpointConfigName": "",
        "ProductionVariants": "",
        "DataCaptureConfig": json!({
            "EnableCapture": "",
            "InitialSamplingPercentage": "",
            "DestinationS3Uri": "",
            "KmsKeyId": "",
            "CaptureOptions": "",
            "CaptureContentTypeHeader": ""
        }),
        "Tags": "",
        "KmsKeyId": "",
        "AsyncInferenceConfig": "",
        "ExplainerConfig": "",
        "ShadowProductionVariants": ""
    });

    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);
}

echo '{
  "EndpointConfigName": "",
  "ProductionVariants": "",
  "DataCaptureConfig": {
    "EnableCapture": "",
    "InitialSamplingPercentage": "",
    "DestinationS3Uri": "",
    "KmsKeyId": "",
    "CaptureOptions": "",
    "CaptureContentTypeHeader": ""
  },
  "Tags": "",
  "KmsKeyId": "",
  "AsyncInferenceConfig": "",
  "ExplainerConfig": "",
  "ShadowProductionVariants": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEndpointConfig' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "EndpointConfigName": "",\n  "ProductionVariants": "",\n  "DataCaptureConfig": {\n    "EnableCapture": "",\n    "InitialSamplingPercentage": "",\n    "DestinationS3Uri": "",\n    "KmsKeyId": "",\n    "CaptureOptions": "",\n    "CaptureContentTypeHeader": ""\n  },\n  "Tags": "",\n  "KmsKeyId": "",\n  "AsyncInferenceConfig": "",\n  "ExplainerConfig": "",\n  "ShadowProductionVariants": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateEndpointConfig'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "EndpointConfigName": "",
  "ProductionVariants": "",
  "DataCaptureConfig": [
    "EnableCapture": "",
    "InitialSamplingPercentage": "",
    "DestinationS3Uri": "",
    "KmsKeyId": "",
    "CaptureOptions": "",
    "CaptureContentTypeHeader": ""
  ],
  "Tags": "",
  "KmsKeyId": "",
  "AsyncInferenceConfig": "",
  "ExplainerConfig": "",
  "ShadowProductionVariants": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateExperiment" {:headers {:x-amz-target ""}
                                                                                     :content-type :json
                                                                                     :form-params {:ExperimentName ""
                                                                                                   :DisplayName ""
                                                                                                   :Description ""
                                                                                                   :Tags ""}})

require "http/client"

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

	payload := strings.NewReader("{\n  \"ExperimentName\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\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: 82

{
  "ExperimentName": "",
  "DisplayName": "",
  "Description": "",
  "Tags": ""
}

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

client.close();

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

const data = JSON.stringify({
  ExperimentName: '',
  DisplayName: '',
  Description: '',
  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=SageMaker.CreateExperiment');
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=SageMaker.CreateExperiment',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ExperimentName: '', DisplayName: '', Description: '', Tags: ''}
};

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

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

const request = require('request');

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

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

req.type('json');
req.send({
  ExperimentName: '',
  DisplayName: '',
  Description: '',
  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=SageMaker.CreateExperiment',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ExperimentName: '', DisplayName: '', Description: '', 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=SageMaker.CreateExperiment';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ExperimentName":"","DisplayName":"","Description":"","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 = @{ @"ExperimentName": @"",
                              @"DisplayName": @"",
                              @"Description": @"",
                              @"Tags": @"" };

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"ExperimentName\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\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=SageMaker.CreateExperiment"

payload = {
    "ExperimentName": "",
    "DisplayName": "",
    "Description": "",
    "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=SageMaker.CreateExperiment"

payload <- "{\n  \"ExperimentName\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\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=SageMaker.CreateExperiment")

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  \"ExperimentName\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\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  \"ExperimentName\": \"\",\n  \"DisplayName\": \"\",\n  \"Description\": \"\",\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=SageMaker.CreateExperiment";

    let payload = json!({
        "ExperimentName": "",
        "DisplayName": "",
        "Description": "",
        "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);
}

echo '{
  "ExperimentName": "",
  "DisplayName": "",
  "Description": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateExperiment' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

CURL *hnd = curl_easy_init();

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

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  \"FeatureGroupName\": \"\",\n  \"RecordIdentifierFeatureName\": \"\",\n  \"EventTimeFeatureName\": \"\",\n  \"FeatureDefinitions\": \"\",\n  \"OnlineStoreConfig\": \"\",\n  \"OfflineStoreConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateFeatureGroup" {:headers {:x-amz-target ""}
                                                                                       :content-type :json
                                                                                       :form-params {:FeatureGroupName ""
                                                                                                     :RecordIdentifierFeatureName ""
                                                                                                     :EventTimeFeatureName ""
                                                                                                     :FeatureDefinitions ""
                                                                                                     :OnlineStoreConfig ""
                                                                                                     :OfflineStoreConfig ""
                                                                                                     :RoleArn ""
                                                                                                     :Description ""
                                                                                                     :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateFeatureGroup"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"FeatureGroupName\": \"\",\n  \"RecordIdentifierFeatureName\": \"\",\n  \"EventTimeFeatureName\": \"\",\n  \"FeatureDefinitions\": \"\",\n  \"OnlineStoreConfig\": \"\",\n  \"OfflineStoreConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Description\": \"\",\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=SageMaker.CreateFeatureGroup"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"FeatureGroupName\": \"\",\n  \"RecordIdentifierFeatureName\": \"\",\n  \"EventTimeFeatureName\": \"\",\n  \"FeatureDefinitions\": \"\",\n  \"OnlineStoreConfig\": \"\",\n  \"OfflineStoreConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Description\": \"\",\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=SageMaker.CreateFeatureGroup");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"FeatureGroupName\": \"\",\n  \"RecordIdentifierFeatureName\": \"\",\n  \"EventTimeFeatureName\": \"\",\n  \"FeatureDefinitions\": \"\",\n  \"OnlineStoreConfig\": \"\",\n  \"OfflineStoreConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Description\": \"\",\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=SageMaker.CreateFeatureGroup"

	payload := strings.NewReader("{\n  \"FeatureGroupName\": \"\",\n  \"RecordIdentifierFeatureName\": \"\",\n  \"EventTimeFeatureName\": \"\",\n  \"FeatureDefinitions\": \"\",\n  \"OnlineStoreConfig\": \"\",\n  \"OfflineStoreConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Description\": \"\",\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: 230

{
  "FeatureGroupName": "",
  "RecordIdentifierFeatureName": "",
  "EventTimeFeatureName": "",
  "FeatureDefinitions": "",
  "OnlineStoreConfig": "",
  "OfflineStoreConfig": "",
  "RoleArn": "",
  "Description": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateFeatureGroup")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"FeatureGroupName\": \"\",\n  \"RecordIdentifierFeatureName\": \"\",\n  \"EventTimeFeatureName\": \"\",\n  \"FeatureDefinitions\": \"\",\n  \"OnlineStoreConfig\": \"\",\n  \"OfflineStoreConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateFeatureGroup"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"FeatureGroupName\": \"\",\n  \"RecordIdentifierFeatureName\": \"\",\n  \"EventTimeFeatureName\": \"\",\n  \"FeatureDefinitions\": \"\",\n  \"OnlineStoreConfig\": \"\",\n  \"OfflineStoreConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Description\": \"\",\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  \"FeatureGroupName\": \"\",\n  \"RecordIdentifierFeatureName\": \"\",\n  \"EventTimeFeatureName\": \"\",\n  \"FeatureDefinitions\": \"\",\n  \"OnlineStoreConfig\": \"\",\n  \"OfflineStoreConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateFeatureGroup")
  .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=SageMaker.CreateFeatureGroup")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"FeatureGroupName\": \"\",\n  \"RecordIdentifierFeatureName\": \"\",\n  \"EventTimeFeatureName\": \"\",\n  \"FeatureDefinitions\": \"\",\n  \"OnlineStoreConfig\": \"\",\n  \"OfflineStoreConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  FeatureGroupName: '',
  RecordIdentifierFeatureName: '',
  EventTimeFeatureName: '',
  FeatureDefinitions: '',
  OnlineStoreConfig: '',
  OfflineStoreConfig: '',
  RoleArn: '',
  Description: '',
  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=SageMaker.CreateFeatureGroup');
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=SageMaker.CreateFeatureGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    FeatureGroupName: '',
    RecordIdentifierFeatureName: '',
    EventTimeFeatureName: '',
    FeatureDefinitions: '',
    OnlineStoreConfig: '',
    OfflineStoreConfig: '',
    RoleArn: '',
    Description: '',
    Tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateFeatureGroup';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FeatureGroupName":"","RecordIdentifierFeatureName":"","EventTimeFeatureName":"","FeatureDefinitions":"","OnlineStoreConfig":"","OfflineStoreConfig":"","RoleArn":"","Description":"","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=SageMaker.CreateFeatureGroup',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "FeatureGroupName": "",\n  "RecordIdentifierFeatureName": "",\n  "EventTimeFeatureName": "",\n  "FeatureDefinitions": "",\n  "OnlineStoreConfig": "",\n  "OfflineStoreConfig": "",\n  "RoleArn": "",\n  "Description": "",\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  \"FeatureGroupName\": \"\",\n  \"RecordIdentifierFeatureName\": \"\",\n  \"EventTimeFeatureName\": \"\",\n  \"FeatureDefinitions\": \"\",\n  \"OnlineStoreConfig\": \"\",\n  \"OfflineStoreConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateFeatureGroup")
  .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({
  FeatureGroupName: '',
  RecordIdentifierFeatureName: '',
  EventTimeFeatureName: '',
  FeatureDefinitions: '',
  OnlineStoreConfig: '',
  OfflineStoreConfig: '',
  RoleArn: '',
  Description: '',
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateFeatureGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    FeatureGroupName: '',
    RecordIdentifierFeatureName: '',
    EventTimeFeatureName: '',
    FeatureDefinitions: '',
    OnlineStoreConfig: '',
    OfflineStoreConfig: '',
    RoleArn: '',
    Description: '',
    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=SageMaker.CreateFeatureGroup');

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

req.type('json');
req.send({
  FeatureGroupName: '',
  RecordIdentifierFeatureName: '',
  EventTimeFeatureName: '',
  FeatureDefinitions: '',
  OnlineStoreConfig: '',
  OfflineStoreConfig: '',
  RoleArn: '',
  Description: '',
  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=SageMaker.CreateFeatureGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    FeatureGroupName: '',
    RecordIdentifierFeatureName: '',
    EventTimeFeatureName: '',
    FeatureDefinitions: '',
    OnlineStoreConfig: '',
    OfflineStoreConfig: '',
    RoleArn: '',
    Description: '',
    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=SageMaker.CreateFeatureGroup';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FeatureGroupName":"","RecordIdentifierFeatureName":"","EventTimeFeatureName":"","FeatureDefinitions":"","OnlineStoreConfig":"","OfflineStoreConfig":"","RoleArn":"","Description":"","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 = @{ @"FeatureGroupName": @"",
                              @"RecordIdentifierFeatureName": @"",
                              @"EventTimeFeatureName": @"",
                              @"FeatureDefinitions": @"",
                              @"OnlineStoreConfig": @"",
                              @"OfflineStoreConfig": @"",
                              @"RoleArn": @"",
                              @"Description": @"",
                              @"Tags": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreateFeatureGroup"]
                                                       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=SageMaker.CreateFeatureGroup" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"FeatureGroupName\": \"\",\n  \"RecordIdentifierFeatureName\": \"\",\n  \"EventTimeFeatureName\": \"\",\n  \"FeatureDefinitions\": \"\",\n  \"OnlineStoreConfig\": \"\",\n  \"OfflineStoreConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateFeatureGroup",
  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([
    'FeatureGroupName' => '',
    'RecordIdentifierFeatureName' => '',
    'EventTimeFeatureName' => '',
    'FeatureDefinitions' => '',
    'OnlineStoreConfig' => '',
    'OfflineStoreConfig' => '',
    'RoleArn' => '',
    'Description' => '',
    '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=SageMaker.CreateFeatureGroup', [
  'body' => '{
  "FeatureGroupName": "",
  "RecordIdentifierFeatureName": "",
  "EventTimeFeatureName": "",
  "FeatureDefinitions": "",
  "OnlineStoreConfig": "",
  "OfflineStoreConfig": "",
  "RoleArn": "",
  "Description": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'FeatureGroupName' => '',
  'RecordIdentifierFeatureName' => '',
  'EventTimeFeatureName' => '',
  'FeatureDefinitions' => '',
  'OnlineStoreConfig' => '',
  'OfflineStoreConfig' => '',
  'RoleArn' => '',
  'Description' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'FeatureGroupName' => '',
  'RecordIdentifierFeatureName' => '',
  'EventTimeFeatureName' => '',
  'FeatureDefinitions' => '',
  'OnlineStoreConfig' => '',
  'OfflineStoreConfig' => '',
  'RoleArn' => '',
  'Description' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateFeatureGroup');
$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=SageMaker.CreateFeatureGroup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FeatureGroupName": "",
  "RecordIdentifierFeatureName": "",
  "EventTimeFeatureName": "",
  "FeatureDefinitions": "",
  "OnlineStoreConfig": "",
  "OfflineStoreConfig": "",
  "RoleArn": "",
  "Description": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateFeatureGroup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FeatureGroupName": "",
  "RecordIdentifierFeatureName": "",
  "EventTimeFeatureName": "",
  "FeatureDefinitions": "",
  "OnlineStoreConfig": "",
  "OfflineStoreConfig": "",
  "RoleArn": "",
  "Description": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"FeatureGroupName\": \"\",\n  \"RecordIdentifierFeatureName\": \"\",\n  \"EventTimeFeatureName\": \"\",\n  \"FeatureDefinitions\": \"\",\n  \"OnlineStoreConfig\": \"\",\n  \"OfflineStoreConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Description\": \"\",\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=SageMaker.CreateFeatureGroup"

payload = {
    "FeatureGroupName": "",
    "RecordIdentifierFeatureName": "",
    "EventTimeFeatureName": "",
    "FeatureDefinitions": "",
    "OnlineStoreConfig": "",
    "OfflineStoreConfig": "",
    "RoleArn": "",
    "Description": "",
    "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=SageMaker.CreateFeatureGroup"

payload <- "{\n  \"FeatureGroupName\": \"\",\n  \"RecordIdentifierFeatureName\": \"\",\n  \"EventTimeFeatureName\": \"\",\n  \"FeatureDefinitions\": \"\",\n  \"OnlineStoreConfig\": \"\",\n  \"OfflineStoreConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Description\": \"\",\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=SageMaker.CreateFeatureGroup")

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  \"FeatureGroupName\": \"\",\n  \"RecordIdentifierFeatureName\": \"\",\n  \"EventTimeFeatureName\": \"\",\n  \"FeatureDefinitions\": \"\",\n  \"OnlineStoreConfig\": \"\",\n  \"OfflineStoreConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Description\": \"\",\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  \"FeatureGroupName\": \"\",\n  \"RecordIdentifierFeatureName\": \"\",\n  \"EventTimeFeatureName\": \"\",\n  \"FeatureDefinitions\": \"\",\n  \"OnlineStoreConfig\": \"\",\n  \"OfflineStoreConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Description\": \"\",\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=SageMaker.CreateFeatureGroup";

    let payload = json!({
        "FeatureGroupName": "",
        "RecordIdentifierFeatureName": "",
        "EventTimeFeatureName": "",
        "FeatureDefinitions": "",
        "OnlineStoreConfig": "",
        "OfflineStoreConfig": "",
        "RoleArn": "",
        "Description": "",
        "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);
}

echo '{
  "FeatureGroupName": "",
  "RecordIdentifierFeatureName": "",
  "EventTimeFeatureName": "",
  "FeatureDefinitions": "",
  "OnlineStoreConfig": "",
  "OfflineStoreConfig": "",
  "RoleArn": "",
  "Description": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateFeatureGroup' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "FeatureGroupName": "",\n  "RecordIdentifierFeatureName": "",\n  "EventTimeFeatureName": "",\n  "FeatureDefinitions": "",\n  "OnlineStoreConfig": "",\n  "OfflineStoreConfig": "",\n  "RoleArn": "",\n  "Description": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateFeatureGroup'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "FeatureGroupName": "",
  "RecordIdentifierFeatureName": "",
  "EventTimeFeatureName": "",
  "FeatureDefinitions": "",
  "OnlineStoreConfig": "",
  "OfflineStoreConfig": "",
  "RoleArn": "",
  "Description": "",
  "Tags": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

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

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  \"FlowDefinitionName\": \"\",\n  \"HumanLoopRequestSource\": \"\",\n  \"HumanLoopActivationConfig\": \"\",\n  \"HumanLoopConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateFlowDefinition" {:headers {:x-amz-target ""}
                                                                                         :content-type :json
                                                                                         :form-params {:FlowDefinitionName ""
                                                                                                       :HumanLoopRequestSource ""
                                                                                                       :HumanLoopActivationConfig ""
                                                                                                       :HumanLoopConfig ""
                                                                                                       :OutputConfig ""
                                                                                                       :RoleArn ""
                                                                                                       :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateFlowDefinition"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"FlowDefinitionName\": \"\",\n  \"HumanLoopRequestSource\": \"\",\n  \"HumanLoopActivationConfig\": \"\",\n  \"HumanLoopConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"RoleArn\": \"\",\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=SageMaker.CreateFlowDefinition"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"FlowDefinitionName\": \"\",\n  \"HumanLoopRequestSource\": \"\",\n  \"HumanLoopActivationConfig\": \"\",\n  \"HumanLoopConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"RoleArn\": \"\",\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=SageMaker.CreateFlowDefinition");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"FlowDefinitionName\": \"\",\n  \"HumanLoopRequestSource\": \"\",\n  \"HumanLoopActivationConfig\": \"\",\n  \"HumanLoopConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"RoleArn\": \"\",\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=SageMaker.CreateFlowDefinition"

	payload := strings.NewReader("{\n  \"FlowDefinitionName\": \"\",\n  \"HumanLoopRequestSource\": \"\",\n  \"HumanLoopActivationConfig\": \"\",\n  \"HumanLoopConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"RoleArn\": \"\",\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: 175

{
  "FlowDefinitionName": "",
  "HumanLoopRequestSource": "",
  "HumanLoopActivationConfig": "",
  "HumanLoopConfig": "",
  "OutputConfig": "",
  "RoleArn": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateFlowDefinition")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"FlowDefinitionName\": \"\",\n  \"HumanLoopRequestSource\": \"\",\n  \"HumanLoopActivationConfig\": \"\",\n  \"HumanLoopConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

const data = JSON.stringify({
  FlowDefinitionName: '',
  HumanLoopRequestSource: '',
  HumanLoopActivationConfig: '',
  HumanLoopConfig: '',
  OutputConfig: '',
  RoleArn: '',
  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=SageMaker.CreateFlowDefinition');
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=SageMaker.CreateFlowDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    FlowDefinitionName: '',
    HumanLoopRequestSource: '',
    HumanLoopActivationConfig: '',
    HumanLoopConfig: '',
    OutputConfig: '',
    RoleArn: '',
    Tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateFlowDefinition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FlowDefinitionName":"","HumanLoopRequestSource":"","HumanLoopActivationConfig":"","HumanLoopConfig":"","OutputConfig":"","RoleArn":"","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=SageMaker.CreateFlowDefinition',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "FlowDefinitionName": "",\n  "HumanLoopRequestSource": "",\n  "HumanLoopActivationConfig": "",\n  "HumanLoopConfig": "",\n  "OutputConfig": "",\n  "RoleArn": "",\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  \"FlowDefinitionName\": \"\",\n  \"HumanLoopRequestSource\": \"\",\n  \"HumanLoopActivationConfig\": \"\",\n  \"HumanLoopConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateFlowDefinition")
  .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({
  FlowDefinitionName: '',
  HumanLoopRequestSource: '',
  HumanLoopActivationConfig: '',
  HumanLoopConfig: '',
  OutputConfig: '',
  RoleArn: '',
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateFlowDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    FlowDefinitionName: '',
    HumanLoopRequestSource: '',
    HumanLoopActivationConfig: '',
    HumanLoopConfig: '',
    OutputConfig: '',
    RoleArn: '',
    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=SageMaker.CreateFlowDefinition');

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

req.type('json');
req.send({
  FlowDefinitionName: '',
  HumanLoopRequestSource: '',
  HumanLoopActivationConfig: '',
  HumanLoopConfig: '',
  OutputConfig: '',
  RoleArn: '',
  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=SageMaker.CreateFlowDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    FlowDefinitionName: '',
    HumanLoopRequestSource: '',
    HumanLoopActivationConfig: '',
    HumanLoopConfig: '',
    OutputConfig: '',
    RoleArn: '',
    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=SageMaker.CreateFlowDefinition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FlowDefinitionName":"","HumanLoopRequestSource":"","HumanLoopActivationConfig":"","HumanLoopConfig":"","OutputConfig":"","RoleArn":"","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 = @{ @"FlowDefinitionName": @"",
                              @"HumanLoopRequestSource": @"",
                              @"HumanLoopActivationConfig": @"",
                              @"HumanLoopConfig": @"",
                              @"OutputConfig": @"",
                              @"RoleArn": @"",
                              @"Tags": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateFlowDefinition",
  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([
    'FlowDefinitionName' => '',
    'HumanLoopRequestSource' => '',
    'HumanLoopActivationConfig' => '',
    'HumanLoopConfig' => '',
    'OutputConfig' => '',
    'RoleArn' => '',
    '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=SageMaker.CreateFlowDefinition', [
  'body' => '{
  "FlowDefinitionName": "",
  "HumanLoopRequestSource": "",
  "HumanLoopActivationConfig": "",
  "HumanLoopConfig": "",
  "OutputConfig": "",
  "RoleArn": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'FlowDefinitionName' => '',
  'HumanLoopRequestSource' => '',
  'HumanLoopActivationConfig' => '',
  'HumanLoopConfig' => '',
  'OutputConfig' => '',
  'RoleArn' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'FlowDefinitionName' => '',
  'HumanLoopRequestSource' => '',
  'HumanLoopActivationConfig' => '',
  'HumanLoopConfig' => '',
  'OutputConfig' => '',
  'RoleArn' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateFlowDefinition');
$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=SageMaker.CreateFlowDefinition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FlowDefinitionName": "",
  "HumanLoopRequestSource": "",
  "HumanLoopActivationConfig": "",
  "HumanLoopConfig": "",
  "OutputConfig": "",
  "RoleArn": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateFlowDefinition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FlowDefinitionName": "",
  "HumanLoopRequestSource": "",
  "HumanLoopActivationConfig": "",
  "HumanLoopConfig": "",
  "OutputConfig": "",
  "RoleArn": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"FlowDefinitionName\": \"\",\n  \"HumanLoopRequestSource\": \"\",\n  \"HumanLoopActivationConfig\": \"\",\n  \"HumanLoopConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"RoleArn\": \"\",\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=SageMaker.CreateFlowDefinition"

payload = {
    "FlowDefinitionName": "",
    "HumanLoopRequestSource": "",
    "HumanLoopActivationConfig": "",
    "HumanLoopConfig": "",
    "OutputConfig": "",
    "RoleArn": "",
    "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=SageMaker.CreateFlowDefinition"

payload <- "{\n  \"FlowDefinitionName\": \"\",\n  \"HumanLoopRequestSource\": \"\",\n  \"HumanLoopActivationConfig\": \"\",\n  \"HumanLoopConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"RoleArn\": \"\",\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=SageMaker.CreateFlowDefinition")

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  \"FlowDefinitionName\": \"\",\n  \"HumanLoopRequestSource\": \"\",\n  \"HumanLoopActivationConfig\": \"\",\n  \"HumanLoopConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"RoleArn\": \"\",\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  \"FlowDefinitionName\": \"\",\n  \"HumanLoopRequestSource\": \"\",\n  \"HumanLoopActivationConfig\": \"\",\n  \"HumanLoopConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"RoleArn\": \"\",\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=SageMaker.CreateFlowDefinition";

    let payload = json!({
        "FlowDefinitionName": "",
        "HumanLoopRequestSource": "",
        "HumanLoopActivationConfig": "",
        "HumanLoopConfig": "",
        "OutputConfig": "",
        "RoleArn": "",
        "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);
}

echo '{
  "FlowDefinitionName": "",
  "HumanLoopRequestSource": "",
  "HumanLoopActivationConfig": "",
  "HumanLoopConfig": "",
  "OutputConfig": "",
  "RoleArn": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateFlowDefinition' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "FlowDefinitionName": "",\n  "HumanLoopRequestSource": "",\n  "HumanLoopActivationConfig": "",\n  "HumanLoopConfig": "",\n  "OutputConfig": "",\n  "RoleArn": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateFlowDefinition'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "FlowDefinitionName": "",
  "HumanLoopRequestSource": "",
  "HumanLoopActivationConfig": "",
  "HumanLoopConfig": "",
  "OutputConfig": "",
  "RoleArn": "",
  "Tags": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

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

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  \"HubName\": \"\",\n  \"HubDescription\": \"\",\n  \"HubDisplayName\": \"\",\n  \"HubSearchKeywords\": \"\",\n  \"S3StorageConfig\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateHub" {:headers {:x-amz-target ""}
                                                                              :content-type :json
                                                                              :form-params {:HubName ""
                                                                                            :HubDescription ""
                                                                                            :HubDisplayName ""
                                                                                            :HubSearchKeywords ""
                                                                                            :S3StorageConfig ""
                                                                                            :Tags ""}})

require "http/client"

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

	payload := strings.NewReader("{\n  \"HubName\": \"\",\n  \"HubDescription\": \"\",\n  \"HubDisplayName\": \"\",\n  \"HubSearchKeywords\": \"\",\n  \"S3StorageConfig\": \"\",\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: 133

{
  "HubName": "",
  "HubDescription": "",
  "HubDisplayName": "",
  "HubSearchKeywords": "",
  "S3StorageConfig": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateHub")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"HubName\": \"\",\n  \"HubDescription\": \"\",\n  \"HubDisplayName\": \"\",\n  \"HubSearchKeywords\": \"\",\n  \"S3StorageConfig\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

const data = JSON.stringify({
  HubName: '',
  HubDescription: '',
  HubDisplayName: '',
  HubSearchKeywords: '',
  S3StorageConfig: '',
  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=SageMaker.CreateHub');
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=SageMaker.CreateHub',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    HubName: '',
    HubDescription: '',
    HubDisplayName: '',
    HubSearchKeywords: '',
    S3StorageConfig: '',
    Tags: ''
  }
};

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

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateHub',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    HubName: '',
    HubDescription: '',
    HubDisplayName: '',
    HubSearchKeywords: '',
    S3StorageConfig: '',
    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=SageMaker.CreateHub');

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

req.type('json');
req.send({
  HubName: '',
  HubDescription: '',
  HubDisplayName: '',
  HubSearchKeywords: '',
  S3StorageConfig: '',
  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=SageMaker.CreateHub',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    HubName: '',
    HubDescription: '',
    HubDisplayName: '',
    HubSearchKeywords: '',
    S3StorageConfig: '',
    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=SageMaker.CreateHub';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"HubName":"","HubDescription":"","HubDisplayName":"","HubSearchKeywords":"","S3StorageConfig":"","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 = @{ @"HubName": @"",
                              @"HubDescription": @"",
                              @"HubDisplayName": @"",
                              @"HubSearchKeywords": @"",
                              @"S3StorageConfig": @"",
                              @"Tags": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateHub",
  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([
    'HubName' => '',
    'HubDescription' => '',
    'HubDisplayName' => '',
    'HubSearchKeywords' => '',
    'S3StorageConfig' => '',
    '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=SageMaker.CreateHub', [
  'body' => '{
  "HubName": "",
  "HubDescription": "",
  "HubDisplayName": "",
  "HubSearchKeywords": "",
  "S3StorageConfig": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'HubName' => '',
  'HubDescription' => '',
  'HubDisplayName' => '',
  'HubSearchKeywords' => '',
  'S3StorageConfig' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'HubName' => '',
  'HubDescription' => '',
  'HubDisplayName' => '',
  'HubSearchKeywords' => '',
  'S3StorageConfig' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateHub');
$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=SageMaker.CreateHub' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "HubName": "",
  "HubDescription": "",
  "HubDisplayName": "",
  "HubSearchKeywords": "",
  "S3StorageConfig": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateHub' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "HubName": "",
  "HubDescription": "",
  "HubDisplayName": "",
  "HubSearchKeywords": "",
  "S3StorageConfig": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"HubName\": \"\",\n  \"HubDescription\": \"\",\n  \"HubDisplayName\": \"\",\n  \"HubSearchKeywords\": \"\",\n  \"S3StorageConfig\": \"\",\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=SageMaker.CreateHub"

payload = {
    "HubName": "",
    "HubDescription": "",
    "HubDisplayName": "",
    "HubSearchKeywords": "",
    "S3StorageConfig": "",
    "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=SageMaker.CreateHub"

payload <- "{\n  \"HubName\": \"\",\n  \"HubDescription\": \"\",\n  \"HubDisplayName\": \"\",\n  \"HubSearchKeywords\": \"\",\n  \"S3StorageConfig\": \"\",\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=SageMaker.CreateHub")

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  \"HubName\": \"\",\n  \"HubDescription\": \"\",\n  \"HubDisplayName\": \"\",\n  \"HubSearchKeywords\": \"\",\n  \"S3StorageConfig\": \"\",\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  \"HubName\": \"\",\n  \"HubDescription\": \"\",\n  \"HubDisplayName\": \"\",\n  \"HubSearchKeywords\": \"\",\n  \"S3StorageConfig\": \"\",\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=SageMaker.CreateHub";

    let payload = json!({
        "HubName": "",
        "HubDescription": "",
        "HubDisplayName": "",
        "HubSearchKeywords": "",
        "S3StorageConfig": "",
        "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);
}

echo '{
  "HubName": "",
  "HubDescription": "",
  "HubDisplayName": "",
  "HubSearchKeywords": "",
  "S3StorageConfig": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateHub' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "HubName": "",\n  "HubDescription": "",\n  "HubDisplayName": "",\n  "HubSearchKeywords": "",\n  "S3StorageConfig": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateHub'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "HubName": "",
  "HubDescription": "",
  "HubDisplayName": "",
  "HubSearchKeywords": "",
  "S3StorageConfig": "",
  "Tags": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

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

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  \"HumanTaskUiName\": \"\",\n  \"UiTemplate\": {\n    \"Content\": \"\"\n  },\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateHumanTaskUi" {:headers {:x-amz-target ""}
                                                                                      :content-type :json
                                                                                      :form-params {:HumanTaskUiName ""
                                                                                                    :UiTemplate {:Content ""}
                                                                                                    :Tags ""}})

require "http/client"

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

	payload := strings.NewReader("{\n  \"HumanTaskUiName\": \"\",\n  \"UiTemplate\": {\n    \"Content\": \"\"\n  },\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: 82

{
  "HumanTaskUiName": "",
  "UiTemplate": {
    "Content": ""
  },
  "Tags": ""
}

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

client.close();

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

const data = JSON.stringify({
  HumanTaskUiName: '',
  UiTemplate: {
    Content: ''
  },
  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=SageMaker.CreateHumanTaskUi');
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=SageMaker.CreateHumanTaskUi',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {HumanTaskUiName: '', UiTemplate: {Content: ''}, Tags: ''}
};

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

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

const request = require('request');

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

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

req.type('json');
req.send({
  HumanTaskUiName: '',
  UiTemplate: {
    Content: ''
  },
  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=SageMaker.CreateHumanTaskUi',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {HumanTaskUiName: '', UiTemplate: {Content: ''}, 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=SageMaker.CreateHumanTaskUi';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"HumanTaskUiName":"","UiTemplate":{"Content":""},"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 = @{ @"HumanTaskUiName": @"",
                              @"UiTemplate": @{ @"Content": @"" },
                              @"Tags": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'HumanTaskUiName' => '',
  'UiTemplate' => [
    'Content' => ''
  ],
  'Tags' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"HumanTaskUiName\": \"\",\n  \"UiTemplate\": {\n    \"Content\": \"\"\n  },\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=SageMaker.CreateHumanTaskUi"

payload = {
    "HumanTaskUiName": "",
    "UiTemplate": { "Content": "" },
    "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=SageMaker.CreateHumanTaskUi"

payload <- "{\n  \"HumanTaskUiName\": \"\",\n  \"UiTemplate\": {\n    \"Content\": \"\"\n  },\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=SageMaker.CreateHumanTaskUi")

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  \"HumanTaskUiName\": \"\",\n  \"UiTemplate\": {\n    \"Content\": \"\"\n  },\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  \"HumanTaskUiName\": \"\",\n  \"UiTemplate\": {\n    \"Content\": \"\"\n  },\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=SageMaker.CreateHumanTaskUi";

    let payload = json!({
        "HumanTaskUiName": "",
        "UiTemplate": json!({"Content": ""}),
        "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);
}

echo '{
  "HumanTaskUiName": "",
  "UiTemplate": {
    "Content": ""
  },
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateHumanTaskUi' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "HumanTaskUiName": "",\n  "UiTemplate": {\n    "Content": ""\n  },\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateHumanTaskUi'

import Foundation

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

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

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

CURL *hnd = curl_easy_init();

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

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  \"HyperParameterTuningJobName\": \"\",\n  \"HyperParameterTuningJobConfig\": \"\",\n  \"TrainingJobDefinition\": \"\",\n  \"TrainingJobDefinitions\": \"\",\n  \"WarmStartConfig\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateHyperParameterTuningJob" {:headers {:x-amz-target ""}
                                                                                                  :content-type :json
                                                                                                  :form-params {:HyperParameterTuningJobName ""
                                                                                                                :HyperParameterTuningJobConfig ""
                                                                                                                :TrainingJobDefinition ""
                                                                                                                :TrainingJobDefinitions ""
                                                                                                                :WarmStartConfig ""
                                                                                                                :Tags ""}})

require "http/client"

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

	payload := strings.NewReader("{\n  \"HyperParameterTuningJobName\": \"\",\n  \"HyperParameterTuningJobConfig\": \"\",\n  \"TrainingJobDefinition\": \"\",\n  \"TrainingJobDefinitions\": \"\",\n  \"WarmStartConfig\": \"\",\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: 180

{
  "HyperParameterTuningJobName": "",
  "HyperParameterTuningJobConfig": "",
  "TrainingJobDefinition": "",
  "TrainingJobDefinitions": "",
  "WarmStartConfig": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateHyperParameterTuningJob")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"HyperParameterTuningJobName\": \"\",\n  \"HyperParameterTuningJobConfig\": \"\",\n  \"TrainingJobDefinition\": \"\",\n  \"TrainingJobDefinitions\": \"\",\n  \"WarmStartConfig\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

const data = JSON.stringify({
  HyperParameterTuningJobName: '',
  HyperParameterTuningJobConfig: '',
  TrainingJobDefinition: '',
  TrainingJobDefinitions: '',
  WarmStartConfig: '',
  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=SageMaker.CreateHyperParameterTuningJob');
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=SageMaker.CreateHyperParameterTuningJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    HyperParameterTuningJobName: '',
    HyperParameterTuningJobConfig: '',
    TrainingJobDefinition: '',
    TrainingJobDefinitions: '',
    WarmStartConfig: '',
    Tags: ''
  }
};

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

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateHyperParameterTuningJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    HyperParameterTuningJobName: '',
    HyperParameterTuningJobConfig: '',
    TrainingJobDefinition: '',
    TrainingJobDefinitions: '',
    WarmStartConfig: '',
    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=SageMaker.CreateHyperParameterTuningJob');

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

req.type('json');
req.send({
  HyperParameterTuningJobName: '',
  HyperParameterTuningJobConfig: '',
  TrainingJobDefinition: '',
  TrainingJobDefinitions: '',
  WarmStartConfig: '',
  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=SageMaker.CreateHyperParameterTuningJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    HyperParameterTuningJobName: '',
    HyperParameterTuningJobConfig: '',
    TrainingJobDefinition: '',
    TrainingJobDefinitions: '',
    WarmStartConfig: '',
    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=SageMaker.CreateHyperParameterTuningJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"HyperParameterTuningJobName":"","HyperParameterTuningJobConfig":"","TrainingJobDefinition":"","TrainingJobDefinitions":"","WarmStartConfig":"","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 = @{ @"HyperParameterTuningJobName": @"",
                              @"HyperParameterTuningJobConfig": @"",
                              @"TrainingJobDefinition": @"",
                              @"TrainingJobDefinitions": @"",
                              @"WarmStartConfig": @"",
                              @"Tags": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateHyperParameterTuningJob",
  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([
    'HyperParameterTuningJobName' => '',
    'HyperParameterTuningJobConfig' => '',
    'TrainingJobDefinition' => '',
    'TrainingJobDefinitions' => '',
    'WarmStartConfig' => '',
    '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=SageMaker.CreateHyperParameterTuningJob', [
  'body' => '{
  "HyperParameterTuningJobName": "",
  "HyperParameterTuningJobConfig": "",
  "TrainingJobDefinition": "",
  "TrainingJobDefinitions": "",
  "WarmStartConfig": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'HyperParameterTuningJobName' => '',
  'HyperParameterTuningJobConfig' => '',
  'TrainingJobDefinition' => '',
  'TrainingJobDefinitions' => '',
  'WarmStartConfig' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'HyperParameterTuningJobName' => '',
  'HyperParameterTuningJobConfig' => '',
  'TrainingJobDefinition' => '',
  'TrainingJobDefinitions' => '',
  'WarmStartConfig' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateHyperParameterTuningJob');
$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=SageMaker.CreateHyperParameterTuningJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "HyperParameterTuningJobName": "",
  "HyperParameterTuningJobConfig": "",
  "TrainingJobDefinition": "",
  "TrainingJobDefinitions": "",
  "WarmStartConfig": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateHyperParameterTuningJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "HyperParameterTuningJobName": "",
  "HyperParameterTuningJobConfig": "",
  "TrainingJobDefinition": "",
  "TrainingJobDefinitions": "",
  "WarmStartConfig": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"HyperParameterTuningJobName\": \"\",\n  \"HyperParameterTuningJobConfig\": \"\",\n  \"TrainingJobDefinition\": \"\",\n  \"TrainingJobDefinitions\": \"\",\n  \"WarmStartConfig\": \"\",\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=SageMaker.CreateHyperParameterTuningJob"

payload = {
    "HyperParameterTuningJobName": "",
    "HyperParameterTuningJobConfig": "",
    "TrainingJobDefinition": "",
    "TrainingJobDefinitions": "",
    "WarmStartConfig": "",
    "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=SageMaker.CreateHyperParameterTuningJob"

payload <- "{\n  \"HyperParameterTuningJobName\": \"\",\n  \"HyperParameterTuningJobConfig\": \"\",\n  \"TrainingJobDefinition\": \"\",\n  \"TrainingJobDefinitions\": \"\",\n  \"WarmStartConfig\": \"\",\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=SageMaker.CreateHyperParameterTuningJob")

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  \"HyperParameterTuningJobName\": \"\",\n  \"HyperParameterTuningJobConfig\": \"\",\n  \"TrainingJobDefinition\": \"\",\n  \"TrainingJobDefinitions\": \"\",\n  \"WarmStartConfig\": \"\",\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  \"HyperParameterTuningJobName\": \"\",\n  \"HyperParameterTuningJobConfig\": \"\",\n  \"TrainingJobDefinition\": \"\",\n  \"TrainingJobDefinitions\": \"\",\n  \"WarmStartConfig\": \"\",\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=SageMaker.CreateHyperParameterTuningJob";

    let payload = json!({
        "HyperParameterTuningJobName": "",
        "HyperParameterTuningJobConfig": "",
        "TrainingJobDefinition": "",
        "TrainingJobDefinitions": "",
        "WarmStartConfig": "",
        "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);
}

echo '{
  "HyperParameterTuningJobName": "",
  "HyperParameterTuningJobConfig": "",
  "TrainingJobDefinition": "",
  "TrainingJobDefinitions": "",
  "WarmStartConfig": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateHyperParameterTuningJob' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "HyperParameterTuningJobName": "",\n  "HyperParameterTuningJobConfig": "",\n  "TrainingJobDefinition": "",\n  "TrainingJobDefinitions": "",\n  "WarmStartConfig": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateHyperParameterTuningJob'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "HyperParameterTuningJobName": "",
  "HyperParameterTuningJobConfig": "",
  "TrainingJobDefinition": "",
  "TrainingJobDefinitions": "",
  "WarmStartConfig": "",
  "Tags": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

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

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  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"ImageName\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateImage" {:headers {:x-amz-target ""}
                                                                                :content-type :json
                                                                                :form-params {:Description ""
                                                                                              :DisplayName ""
                                                                                              :ImageName ""
                                                                                              :RoleArn ""
                                                                                              :Tags ""}})

require "http/client"

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

	payload := strings.NewReader("{\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"ImageName\": \"\",\n  \"RoleArn\": \"\",\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: 94

{
  "Description": "",
  "DisplayName": "",
  "ImageName": "",
  "RoleArn": "",
  "Tags": ""
}

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

client.close();

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

const data = JSON.stringify({
  Description: '',
  DisplayName: '',
  ImageName: '',
  RoleArn: '',
  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=SageMaker.CreateImage');
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=SageMaker.CreateImage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Description: '', DisplayName: '', ImageName: '', RoleArn: '', Tags: ''}
};

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

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

const request = require('request');

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

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

req.type('json');
req.send({
  Description: '',
  DisplayName: '',
  ImageName: '',
  RoleArn: '',
  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=SageMaker.CreateImage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Description: '', DisplayName: '', ImageName: '', RoleArn: '', 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=SageMaker.CreateImage';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Description":"","DisplayName":"","ImageName":"","RoleArn":"","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 = @{ @"Description": @"",
                              @"DisplayName": @"",
                              @"ImageName": @"",
                              @"RoleArn": @"",
                              @"Tags": @"" };

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"ImageName\": \"\",\n  \"RoleArn\": \"\",\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=SageMaker.CreateImage"

payload = {
    "Description": "",
    "DisplayName": "",
    "ImageName": "",
    "RoleArn": "",
    "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=SageMaker.CreateImage"

payload <- "{\n  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"ImageName\": \"\",\n  \"RoleArn\": \"\",\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=SageMaker.CreateImage")

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  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"ImageName\": \"\",\n  \"RoleArn\": \"\",\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  \"Description\": \"\",\n  \"DisplayName\": \"\",\n  \"ImageName\": \"\",\n  \"RoleArn\": \"\",\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=SageMaker.CreateImage";

    let payload = json!({
        "Description": "",
        "DisplayName": "",
        "ImageName": "",
        "RoleArn": "",
        "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);
}

echo '{
  "Description": "",
  "DisplayName": "",
  "ImageName": "",
  "RoleArn": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateImage' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

CURL *hnd = curl_easy_init();

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

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  \"BaseImage\": \"\",\n  \"ClientToken\": \"\",\n  \"ImageName\": \"\",\n  \"Aliases\": \"\",\n  \"VendorGuidance\": \"\",\n  \"JobType\": \"\",\n  \"MLFramework\": \"\",\n  \"ProgrammingLang\": \"\",\n  \"Processor\": \"\",\n  \"Horovod\": \"\",\n  \"ReleaseNotes\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateImageVersion" {:headers {:x-amz-target ""}
                                                                                       :content-type :json
                                                                                       :form-params {:BaseImage ""
                                                                                                     :ClientToken ""
                                                                                                     :ImageName ""
                                                                                                     :Aliases ""
                                                                                                     :VendorGuidance ""
                                                                                                     :JobType ""
                                                                                                     :MLFramework ""
                                                                                                     :ProgrammingLang ""
                                                                                                     :Processor ""
                                                                                                     :Horovod ""
                                                                                                     :ReleaseNotes ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateImageVersion"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"BaseImage\": \"\",\n  \"ClientToken\": \"\",\n  \"ImageName\": \"\",\n  \"Aliases\": \"\",\n  \"VendorGuidance\": \"\",\n  \"JobType\": \"\",\n  \"MLFramework\": \"\",\n  \"ProgrammingLang\": \"\",\n  \"Processor\": \"\",\n  \"Horovod\": \"\",\n  \"ReleaseNotes\": \"\"\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=SageMaker.CreateImageVersion"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"BaseImage\": \"\",\n  \"ClientToken\": \"\",\n  \"ImageName\": \"\",\n  \"Aliases\": \"\",\n  \"VendorGuidance\": \"\",\n  \"JobType\": \"\",\n  \"MLFramework\": \"\",\n  \"ProgrammingLang\": \"\",\n  \"Processor\": \"\",\n  \"Horovod\": \"\",\n  \"ReleaseNotes\": \"\"\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=SageMaker.CreateImageVersion");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"BaseImage\": \"\",\n  \"ClientToken\": \"\",\n  \"ImageName\": \"\",\n  \"Aliases\": \"\",\n  \"VendorGuidance\": \"\",\n  \"JobType\": \"\",\n  \"MLFramework\": \"\",\n  \"ProgrammingLang\": \"\",\n  \"Processor\": \"\",\n  \"Horovod\": \"\",\n  \"ReleaseNotes\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateImageVersion"

	payload := strings.NewReader("{\n  \"BaseImage\": \"\",\n  \"ClientToken\": \"\",\n  \"ImageName\": \"\",\n  \"Aliases\": \"\",\n  \"VendorGuidance\": \"\",\n  \"JobType\": \"\",\n  \"MLFramework\": \"\",\n  \"ProgrammingLang\": \"\",\n  \"Processor\": \"\",\n  \"Horovod\": \"\",\n  \"ReleaseNotes\": \"\"\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: 223

{
  "BaseImage": "",
  "ClientToken": "",
  "ImageName": "",
  "Aliases": "",
  "VendorGuidance": "",
  "JobType": "",
  "MLFramework": "",
  "ProgrammingLang": "",
  "Processor": "",
  "Horovod": "",
  "ReleaseNotes": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateImageVersion")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"BaseImage\": \"\",\n  \"ClientToken\": \"\",\n  \"ImageName\": \"\",\n  \"Aliases\": \"\",\n  \"VendorGuidance\": \"\",\n  \"JobType\": \"\",\n  \"MLFramework\": \"\",\n  \"ProgrammingLang\": \"\",\n  \"Processor\": \"\",\n  \"Horovod\": \"\",\n  \"ReleaseNotes\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateImageVersion"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"BaseImage\": \"\",\n  \"ClientToken\": \"\",\n  \"ImageName\": \"\",\n  \"Aliases\": \"\",\n  \"VendorGuidance\": \"\",\n  \"JobType\": \"\",\n  \"MLFramework\": \"\",\n  \"ProgrammingLang\": \"\",\n  \"Processor\": \"\",\n  \"Horovod\": \"\",\n  \"ReleaseNotes\": \"\"\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  \"BaseImage\": \"\",\n  \"ClientToken\": \"\",\n  \"ImageName\": \"\",\n  \"Aliases\": \"\",\n  \"VendorGuidance\": \"\",\n  \"JobType\": \"\",\n  \"MLFramework\": \"\",\n  \"ProgrammingLang\": \"\",\n  \"Processor\": \"\",\n  \"Horovod\": \"\",\n  \"ReleaseNotes\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateImageVersion")
  .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=SageMaker.CreateImageVersion")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"BaseImage\": \"\",\n  \"ClientToken\": \"\",\n  \"ImageName\": \"\",\n  \"Aliases\": \"\",\n  \"VendorGuidance\": \"\",\n  \"JobType\": \"\",\n  \"MLFramework\": \"\",\n  \"ProgrammingLang\": \"\",\n  \"Processor\": \"\",\n  \"Horovod\": \"\",\n  \"ReleaseNotes\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  BaseImage: '',
  ClientToken: '',
  ImageName: '',
  Aliases: '',
  VendorGuidance: '',
  JobType: '',
  MLFramework: '',
  ProgrammingLang: '',
  Processor: '',
  Horovod: '',
  ReleaseNotes: ''
});

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=SageMaker.CreateImageVersion');
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=SageMaker.CreateImageVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    BaseImage: '',
    ClientToken: '',
    ImageName: '',
    Aliases: '',
    VendorGuidance: '',
    JobType: '',
    MLFramework: '',
    ProgrammingLang: '',
    Processor: '',
    Horovod: '',
    ReleaseNotes: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateImageVersion';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"BaseImage":"","ClientToken":"","ImageName":"","Aliases":"","VendorGuidance":"","JobType":"","MLFramework":"","ProgrammingLang":"","Processor":"","Horovod":"","ReleaseNotes":""}'
};

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=SageMaker.CreateImageVersion',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "BaseImage": "",\n  "ClientToken": "",\n  "ImageName": "",\n  "Aliases": "",\n  "VendorGuidance": "",\n  "JobType": "",\n  "MLFramework": "",\n  "ProgrammingLang": "",\n  "Processor": "",\n  "Horovod": "",\n  "ReleaseNotes": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"BaseImage\": \"\",\n  \"ClientToken\": \"\",\n  \"ImageName\": \"\",\n  \"Aliases\": \"\",\n  \"VendorGuidance\": \"\",\n  \"JobType\": \"\",\n  \"MLFramework\": \"\",\n  \"ProgrammingLang\": \"\",\n  \"Processor\": \"\",\n  \"Horovod\": \"\",\n  \"ReleaseNotes\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateImageVersion")
  .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({
  BaseImage: '',
  ClientToken: '',
  ImageName: '',
  Aliases: '',
  VendorGuidance: '',
  JobType: '',
  MLFramework: '',
  ProgrammingLang: '',
  Processor: '',
  Horovod: '',
  ReleaseNotes: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateImageVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    BaseImage: '',
    ClientToken: '',
    ImageName: '',
    Aliases: '',
    VendorGuidance: '',
    JobType: '',
    MLFramework: '',
    ProgrammingLang: '',
    Processor: '',
    Horovod: '',
    ReleaseNotes: ''
  },
  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=SageMaker.CreateImageVersion');

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

req.type('json');
req.send({
  BaseImage: '',
  ClientToken: '',
  ImageName: '',
  Aliases: '',
  VendorGuidance: '',
  JobType: '',
  MLFramework: '',
  ProgrammingLang: '',
  Processor: '',
  Horovod: '',
  ReleaseNotes: ''
});

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=SageMaker.CreateImageVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    BaseImage: '',
    ClientToken: '',
    ImageName: '',
    Aliases: '',
    VendorGuidance: '',
    JobType: '',
    MLFramework: '',
    ProgrammingLang: '',
    Processor: '',
    Horovod: '',
    ReleaseNotes: ''
  }
};

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=SageMaker.CreateImageVersion';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"BaseImage":"","ClientToken":"","ImageName":"","Aliases":"","VendorGuidance":"","JobType":"","MLFramework":"","ProgrammingLang":"","Processor":"","Horovod":"","ReleaseNotes":""}'
};

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 = @{ @"BaseImage": @"",
                              @"ClientToken": @"",
                              @"ImageName": @"",
                              @"Aliases": @"",
                              @"VendorGuidance": @"",
                              @"JobType": @"",
                              @"MLFramework": @"",
                              @"ProgrammingLang": @"",
                              @"Processor": @"",
                              @"Horovod": @"",
                              @"ReleaseNotes": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreateImageVersion"]
                                                       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=SageMaker.CreateImageVersion" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"BaseImage\": \"\",\n  \"ClientToken\": \"\",\n  \"ImageName\": \"\",\n  \"Aliases\": \"\",\n  \"VendorGuidance\": \"\",\n  \"JobType\": \"\",\n  \"MLFramework\": \"\",\n  \"ProgrammingLang\": \"\",\n  \"Processor\": \"\",\n  \"Horovod\": \"\",\n  \"ReleaseNotes\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateImageVersion",
  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([
    'BaseImage' => '',
    'ClientToken' => '',
    'ImageName' => '',
    'Aliases' => '',
    'VendorGuidance' => '',
    'JobType' => '',
    'MLFramework' => '',
    'ProgrammingLang' => '',
    'Processor' => '',
    'Horovod' => '',
    'ReleaseNotes' => ''
  ]),
  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=SageMaker.CreateImageVersion', [
  'body' => '{
  "BaseImage": "",
  "ClientToken": "",
  "ImageName": "",
  "Aliases": "",
  "VendorGuidance": "",
  "JobType": "",
  "MLFramework": "",
  "ProgrammingLang": "",
  "Processor": "",
  "Horovod": "",
  "ReleaseNotes": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'BaseImage' => '',
  'ClientToken' => '',
  'ImageName' => '',
  'Aliases' => '',
  'VendorGuidance' => '',
  'JobType' => '',
  'MLFramework' => '',
  'ProgrammingLang' => '',
  'Processor' => '',
  'Horovod' => '',
  'ReleaseNotes' => ''
]));

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

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

append(json_encode([
  'BaseImage' => '',
  'ClientToken' => '',
  'ImageName' => '',
  'Aliases' => '',
  'VendorGuidance' => '',
  'JobType' => '',
  'MLFramework' => '',
  'ProgrammingLang' => '',
  'Processor' => '',
  'Horovod' => '',
  'ReleaseNotes' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateImageVersion');
$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=SageMaker.CreateImageVersion' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "BaseImage": "",
  "ClientToken": "",
  "ImageName": "",
  "Aliases": "",
  "VendorGuidance": "",
  "JobType": "",
  "MLFramework": "",
  "ProgrammingLang": "",
  "Processor": "",
  "Horovod": "",
  "ReleaseNotes": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateImageVersion' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "BaseImage": "",
  "ClientToken": "",
  "ImageName": "",
  "Aliases": "",
  "VendorGuidance": "",
  "JobType": "",
  "MLFramework": "",
  "ProgrammingLang": "",
  "Processor": "",
  "Horovod": "",
  "ReleaseNotes": ""
}'

import http.client

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

payload = "{\n  \"BaseImage\": \"\",\n  \"ClientToken\": \"\",\n  \"ImageName\": \"\",\n  \"Aliases\": \"\",\n  \"VendorGuidance\": \"\",\n  \"JobType\": \"\",\n  \"MLFramework\": \"\",\n  \"ProgrammingLang\": \"\",\n  \"Processor\": \"\",\n  \"Horovod\": \"\",\n  \"ReleaseNotes\": \"\"\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=SageMaker.CreateImageVersion"

payload = {
    "BaseImage": "",
    "ClientToken": "",
    "ImageName": "",
    "Aliases": "",
    "VendorGuidance": "",
    "JobType": "",
    "MLFramework": "",
    "ProgrammingLang": "",
    "Processor": "",
    "Horovod": "",
    "ReleaseNotes": ""
}
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=SageMaker.CreateImageVersion"

payload <- "{\n  \"BaseImage\": \"\",\n  \"ClientToken\": \"\",\n  \"ImageName\": \"\",\n  \"Aliases\": \"\",\n  \"VendorGuidance\": \"\",\n  \"JobType\": \"\",\n  \"MLFramework\": \"\",\n  \"ProgrammingLang\": \"\",\n  \"Processor\": \"\",\n  \"Horovod\": \"\",\n  \"ReleaseNotes\": \"\"\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=SageMaker.CreateImageVersion")

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  \"BaseImage\": \"\",\n  \"ClientToken\": \"\",\n  \"ImageName\": \"\",\n  \"Aliases\": \"\",\n  \"VendorGuidance\": \"\",\n  \"JobType\": \"\",\n  \"MLFramework\": \"\",\n  \"ProgrammingLang\": \"\",\n  \"Processor\": \"\",\n  \"Horovod\": \"\",\n  \"ReleaseNotes\": \"\"\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  \"BaseImage\": \"\",\n  \"ClientToken\": \"\",\n  \"ImageName\": \"\",\n  \"Aliases\": \"\",\n  \"VendorGuidance\": \"\",\n  \"JobType\": \"\",\n  \"MLFramework\": \"\",\n  \"ProgrammingLang\": \"\",\n  \"Processor\": \"\",\n  \"Horovod\": \"\",\n  \"ReleaseNotes\": \"\"\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=SageMaker.CreateImageVersion";

    let payload = json!({
        "BaseImage": "",
        "ClientToken": "",
        "ImageName": "",
        "Aliases": "",
        "VendorGuidance": "",
        "JobType": "",
        "MLFramework": "",
        "ProgrammingLang": "",
        "Processor": "",
        "Horovod": "",
        "ReleaseNotes": ""
    });

    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);
}

echo '{
  "BaseImage": "",
  "ClientToken": "",
  "ImageName": "",
  "Aliases": "",
  "VendorGuidance": "",
  "JobType": "",
  "MLFramework": "",
  "ProgrammingLang": "",
  "Processor": "",
  "Horovod": "",
  "ReleaseNotes": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateImageVersion' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "BaseImage": "",\n  "ClientToken": "",\n  "ImageName": "",\n  "Aliases": "",\n  "VendorGuidance": "",\n  "JobType": "",\n  "MLFramework": "",\n  "ProgrammingLang": "",\n  "Processor": "",\n  "Horovod": "",\n  "ReleaseNotes": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateImageVersion'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "BaseImage": "",
  "ClientToken": "",
  "ImageName": "",
  "Aliases": "",
  "VendorGuidance": "",
  "JobType": "",
  "MLFramework": "",
  "ProgrammingLang": "",
  "Processor": "",
  "Horovod": "",
  "ReleaseNotes": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

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

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  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"EndpointName\": \"\",\n  \"ModelVariants\": \"\",\n  \"DataStorageConfig\": \"\",\n  \"ShadowModeConfig\": \"\",\n  \"KmsKey\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateInferenceExperiment" {:headers {:x-amz-target ""}
                                                                                              :content-type :json
                                                                                              :form-params {:Name ""
                                                                                                            :Type ""
                                                                                                            :Schedule ""
                                                                                                            :Description ""
                                                                                                            :RoleArn ""
                                                                                                            :EndpointName ""
                                                                                                            :ModelVariants ""
                                                                                                            :DataStorageConfig ""
                                                                                                            :ShadowModeConfig ""
                                                                                                            :KmsKey ""
                                                                                                            :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateInferenceExperiment"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"EndpointName\": \"\",\n  \"ModelVariants\": \"\",\n  \"DataStorageConfig\": \"\",\n  \"ShadowModeConfig\": \"\",\n  \"KmsKey\": \"\",\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=SageMaker.CreateInferenceExperiment"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"EndpointName\": \"\",\n  \"ModelVariants\": \"\",\n  \"DataStorageConfig\": \"\",\n  \"ShadowModeConfig\": \"\",\n  \"KmsKey\": \"\",\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=SageMaker.CreateInferenceExperiment");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"EndpointName\": \"\",\n  \"ModelVariants\": \"\",\n  \"DataStorageConfig\": \"\",\n  \"ShadowModeConfig\": \"\",\n  \"KmsKey\": \"\",\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=SageMaker.CreateInferenceExperiment"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"EndpointName\": \"\",\n  \"ModelVariants\": \"\",\n  \"DataStorageConfig\": \"\",\n  \"ShadowModeConfig\": \"\",\n  \"KmsKey\": \"\",\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: 214

{
  "Name": "",
  "Type": "",
  "Schedule": "",
  "Description": "",
  "RoleArn": "",
  "EndpointName": "",
  "ModelVariants": "",
  "DataStorageConfig": "",
  "ShadowModeConfig": "",
  "KmsKey": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateInferenceExperiment")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"EndpointName\": \"\",\n  \"ModelVariants\": \"\",\n  \"DataStorageConfig\": \"\",\n  \"ShadowModeConfig\": \"\",\n  \"KmsKey\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateInferenceExperiment"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"EndpointName\": \"\",\n  \"ModelVariants\": \"\",\n  \"DataStorageConfig\": \"\",\n  \"ShadowModeConfig\": \"\",\n  \"KmsKey\": \"\",\n  \"Tags\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"EndpointName\": \"\",\n  \"ModelVariants\": \"\",\n  \"DataStorageConfig\": \"\",\n  \"ShadowModeConfig\": \"\",\n  \"KmsKey\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateInferenceExperiment")
  .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=SageMaker.CreateInferenceExperiment")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"EndpointName\": \"\",\n  \"ModelVariants\": \"\",\n  \"DataStorageConfig\": \"\",\n  \"ShadowModeConfig\": \"\",\n  \"KmsKey\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Type: '',
  Schedule: '',
  Description: '',
  RoleArn: '',
  EndpointName: '',
  ModelVariants: '',
  DataStorageConfig: '',
  ShadowModeConfig: '',
  KmsKey: '',
  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=SageMaker.CreateInferenceExperiment');
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=SageMaker.CreateInferenceExperiment',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    Type: '',
    Schedule: '',
    Description: '',
    RoleArn: '',
    EndpointName: '',
    ModelVariants: '',
    DataStorageConfig: '',
    ShadowModeConfig: '',
    KmsKey: '',
    Tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateInferenceExperiment';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","Type":"","Schedule":"","Description":"","RoleArn":"","EndpointName":"","ModelVariants":"","DataStorageConfig":"","ShadowModeConfig":"","KmsKey":"","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=SageMaker.CreateInferenceExperiment',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Type": "",\n  "Schedule": "",\n  "Description": "",\n  "RoleArn": "",\n  "EndpointName": "",\n  "ModelVariants": "",\n  "DataStorageConfig": "",\n  "ShadowModeConfig": "",\n  "KmsKey": "",\n  "Tags": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"EndpointName\": \"\",\n  \"ModelVariants\": \"\",\n  \"DataStorageConfig\": \"\",\n  \"ShadowModeConfig\": \"\",\n  \"KmsKey\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateInferenceExperiment")
  .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: '',
  Type: '',
  Schedule: '',
  Description: '',
  RoleArn: '',
  EndpointName: '',
  ModelVariants: '',
  DataStorageConfig: '',
  ShadowModeConfig: '',
  KmsKey: '',
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateInferenceExperiment',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    Name: '',
    Type: '',
    Schedule: '',
    Description: '',
    RoleArn: '',
    EndpointName: '',
    ModelVariants: '',
    DataStorageConfig: '',
    ShadowModeConfig: '',
    KmsKey: '',
    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=SageMaker.CreateInferenceExperiment');

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

req.type('json');
req.send({
  Name: '',
  Type: '',
  Schedule: '',
  Description: '',
  RoleArn: '',
  EndpointName: '',
  ModelVariants: '',
  DataStorageConfig: '',
  ShadowModeConfig: '',
  KmsKey: '',
  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=SageMaker.CreateInferenceExperiment',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    Type: '',
    Schedule: '',
    Description: '',
    RoleArn: '',
    EndpointName: '',
    ModelVariants: '',
    DataStorageConfig: '',
    ShadowModeConfig: '',
    KmsKey: '',
    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=SageMaker.CreateInferenceExperiment';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","Type":"","Schedule":"","Description":"","RoleArn":"","EndpointName":"","ModelVariants":"","DataStorageConfig":"","ShadowModeConfig":"","KmsKey":"","Tags":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"Type": @"",
                              @"Schedule": @"",
                              @"Description": @"",
                              @"RoleArn": @"",
                              @"EndpointName": @"",
                              @"ModelVariants": @"",
                              @"DataStorageConfig": @"",
                              @"ShadowModeConfig": @"",
                              @"KmsKey": @"",
                              @"Tags": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreateInferenceExperiment"]
                                                       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=SageMaker.CreateInferenceExperiment" 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  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"EndpointName\": \"\",\n  \"ModelVariants\": \"\",\n  \"DataStorageConfig\": \"\",\n  \"ShadowModeConfig\": \"\",\n  \"KmsKey\": \"\",\n  \"Tags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateInferenceExperiment",
  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' => '',
    'Type' => '',
    'Schedule' => '',
    'Description' => '',
    'RoleArn' => '',
    'EndpointName' => '',
    'ModelVariants' => '',
    'DataStorageConfig' => '',
    'ShadowModeConfig' => '',
    'KmsKey' => '',
    '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=SageMaker.CreateInferenceExperiment', [
  'body' => '{
  "Name": "",
  "Type": "",
  "Schedule": "",
  "Description": "",
  "RoleArn": "",
  "EndpointName": "",
  "ModelVariants": "",
  "DataStorageConfig": "",
  "ShadowModeConfig": "",
  "KmsKey": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Type' => '',
  'Schedule' => '',
  'Description' => '',
  'RoleArn' => '',
  'EndpointName' => '',
  'ModelVariants' => '',
  'DataStorageConfig' => '',
  'ShadowModeConfig' => '',
  'KmsKey' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'Name' => '',
  'Type' => '',
  'Schedule' => '',
  'Description' => '',
  'RoleArn' => '',
  'EndpointName' => '',
  'ModelVariants' => '',
  'DataStorageConfig' => '',
  'ShadowModeConfig' => '',
  'KmsKey' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateInferenceExperiment');
$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=SageMaker.CreateInferenceExperiment' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Type": "",
  "Schedule": "",
  "Description": "",
  "RoleArn": "",
  "EndpointName": "",
  "ModelVariants": "",
  "DataStorageConfig": "",
  "ShadowModeConfig": "",
  "KmsKey": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateInferenceExperiment' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Type": "",
  "Schedule": "",
  "Description": "",
  "RoleArn": "",
  "EndpointName": "",
  "ModelVariants": "",
  "DataStorageConfig": "",
  "ShadowModeConfig": "",
  "KmsKey": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"EndpointName\": \"\",\n  \"ModelVariants\": \"\",\n  \"DataStorageConfig\": \"\",\n  \"ShadowModeConfig\": \"\",\n  \"KmsKey\": \"\",\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=SageMaker.CreateInferenceExperiment"

payload = {
    "Name": "",
    "Type": "",
    "Schedule": "",
    "Description": "",
    "RoleArn": "",
    "EndpointName": "",
    "ModelVariants": "",
    "DataStorageConfig": "",
    "ShadowModeConfig": "",
    "KmsKey": "",
    "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=SageMaker.CreateInferenceExperiment"

payload <- "{\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"EndpointName\": \"\",\n  \"ModelVariants\": \"\",\n  \"DataStorageConfig\": \"\",\n  \"ShadowModeConfig\": \"\",\n  \"KmsKey\": \"\",\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=SageMaker.CreateInferenceExperiment")

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  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"EndpointName\": \"\",\n  \"ModelVariants\": \"\",\n  \"DataStorageConfig\": \"\",\n  \"ShadowModeConfig\": \"\",\n  \"KmsKey\": \"\",\n  \"Tags\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"EndpointName\": \"\",\n  \"ModelVariants\": \"\",\n  \"DataStorageConfig\": \"\",\n  \"ShadowModeConfig\": \"\",\n  \"KmsKey\": \"\",\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=SageMaker.CreateInferenceExperiment";

    let payload = json!({
        "Name": "",
        "Type": "",
        "Schedule": "",
        "Description": "",
        "RoleArn": "",
        "EndpointName": "",
        "ModelVariants": "",
        "DataStorageConfig": "",
        "ShadowModeConfig": "",
        "KmsKey": "",
        "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);
}

echo '{
  "Name": "",
  "Type": "",
  "Schedule": "",
  "Description": "",
  "RoleArn": "",
  "EndpointName": "",
  "ModelVariants": "",
  "DataStorageConfig": "",
  "ShadowModeConfig": "",
  "KmsKey": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateInferenceExperiment' \
  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  "Type": "",\n  "Schedule": "",\n  "Description": "",\n  "RoleArn": "",\n  "EndpointName": "",\n  "ModelVariants": "",\n  "DataStorageConfig": "",\n  "ShadowModeConfig": "",\n  "KmsKey": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateInferenceExperiment'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "Type": "",
  "Schedule": "",
  "Description": "",
  "RoleArn": "",
  "EndpointName": "",
  "ModelVariants": "",
  "DataStorageConfig": "",
  "ShadowModeConfig": "",
  "KmsKey": "",
  "Tags": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

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

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  \"JobName\": \"\",\n  \"JobType\": \"\",\n  \"RoleArn\": \"\",\n  \"InputConfig\": \"\",\n  \"JobDescription\": \"\",\n  \"StoppingConditions\": \"\",\n  \"OutputConfig\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateInferenceRecommendationsJob" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:JobName ""
                                                                                                                    :JobType ""
                                                                                                                    :RoleArn ""
                                                                                                                    :InputConfig ""
                                                                                                                    :JobDescription ""
                                                                                                                    :StoppingConditions ""
                                                                                                                    :OutputConfig ""
                                                                                                                    :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateInferenceRecommendationsJob"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"JobName\": \"\",\n  \"JobType\": \"\",\n  \"RoleArn\": \"\",\n  \"InputConfig\": \"\",\n  \"JobDescription\": \"\",\n  \"StoppingConditions\": \"\",\n  \"OutputConfig\": \"\",\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=SageMaker.CreateInferenceRecommendationsJob"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"JobName\": \"\",\n  \"JobType\": \"\",\n  \"RoleArn\": \"\",\n  \"InputConfig\": \"\",\n  \"JobDescription\": \"\",\n  \"StoppingConditions\": \"\",\n  \"OutputConfig\": \"\",\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=SageMaker.CreateInferenceRecommendationsJob");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"JobName\": \"\",\n  \"JobType\": \"\",\n  \"RoleArn\": \"\",\n  \"InputConfig\": \"\",\n  \"JobDescription\": \"\",\n  \"StoppingConditions\": \"\",\n  \"OutputConfig\": \"\",\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=SageMaker.CreateInferenceRecommendationsJob"

	payload := strings.NewReader("{\n  \"JobName\": \"\",\n  \"JobType\": \"\",\n  \"RoleArn\": \"\",\n  \"InputConfig\": \"\",\n  \"JobDescription\": \"\",\n  \"StoppingConditions\": \"\",\n  \"OutputConfig\": \"\",\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: 162

{
  "JobName": "",
  "JobType": "",
  "RoleArn": "",
  "InputConfig": "",
  "JobDescription": "",
  "StoppingConditions": "",
  "OutputConfig": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateInferenceRecommendationsJob")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"JobName\": \"\",\n  \"JobType\": \"\",\n  \"RoleArn\": \"\",\n  \"InputConfig\": \"\",\n  \"JobDescription\": \"\",\n  \"StoppingConditions\": \"\",\n  \"OutputConfig\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateInferenceRecommendationsJob"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"JobName\": \"\",\n  \"JobType\": \"\",\n  \"RoleArn\": \"\",\n  \"InputConfig\": \"\",\n  \"JobDescription\": \"\",\n  \"StoppingConditions\": \"\",\n  \"OutputConfig\": \"\",\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  \"JobName\": \"\",\n  \"JobType\": \"\",\n  \"RoleArn\": \"\",\n  \"InputConfig\": \"\",\n  \"JobDescription\": \"\",\n  \"StoppingConditions\": \"\",\n  \"OutputConfig\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateInferenceRecommendationsJob")
  .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=SageMaker.CreateInferenceRecommendationsJob")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"JobName\": \"\",\n  \"JobType\": \"\",\n  \"RoleArn\": \"\",\n  \"InputConfig\": \"\",\n  \"JobDescription\": \"\",\n  \"StoppingConditions\": \"\",\n  \"OutputConfig\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  JobName: '',
  JobType: '',
  RoleArn: '',
  InputConfig: '',
  JobDescription: '',
  StoppingConditions: '',
  OutputConfig: '',
  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=SageMaker.CreateInferenceRecommendationsJob');
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=SageMaker.CreateInferenceRecommendationsJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    JobName: '',
    JobType: '',
    RoleArn: '',
    InputConfig: '',
    JobDescription: '',
    StoppingConditions: '',
    OutputConfig: '',
    Tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateInferenceRecommendationsJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"JobName":"","JobType":"","RoleArn":"","InputConfig":"","JobDescription":"","StoppingConditions":"","OutputConfig":"","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=SageMaker.CreateInferenceRecommendationsJob',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "JobName": "",\n  "JobType": "",\n  "RoleArn": "",\n  "InputConfig": "",\n  "JobDescription": "",\n  "StoppingConditions": "",\n  "OutputConfig": "",\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  \"JobName\": \"\",\n  \"JobType\": \"\",\n  \"RoleArn\": \"\",\n  \"InputConfig\": \"\",\n  \"JobDescription\": \"\",\n  \"StoppingConditions\": \"\",\n  \"OutputConfig\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateInferenceRecommendationsJob")
  .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({
  JobName: '',
  JobType: '',
  RoleArn: '',
  InputConfig: '',
  JobDescription: '',
  StoppingConditions: '',
  OutputConfig: '',
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateInferenceRecommendationsJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    JobName: '',
    JobType: '',
    RoleArn: '',
    InputConfig: '',
    JobDescription: '',
    StoppingConditions: '',
    OutputConfig: '',
    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=SageMaker.CreateInferenceRecommendationsJob');

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

req.type('json');
req.send({
  JobName: '',
  JobType: '',
  RoleArn: '',
  InputConfig: '',
  JobDescription: '',
  StoppingConditions: '',
  OutputConfig: '',
  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=SageMaker.CreateInferenceRecommendationsJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    JobName: '',
    JobType: '',
    RoleArn: '',
    InputConfig: '',
    JobDescription: '',
    StoppingConditions: '',
    OutputConfig: '',
    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=SageMaker.CreateInferenceRecommendationsJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"JobName":"","JobType":"","RoleArn":"","InputConfig":"","JobDescription":"","StoppingConditions":"","OutputConfig":"","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 = @{ @"JobName": @"",
                              @"JobType": @"",
                              @"RoleArn": @"",
                              @"InputConfig": @"",
                              @"JobDescription": @"",
                              @"StoppingConditions": @"",
                              @"OutputConfig": @"",
                              @"Tags": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreateInferenceRecommendationsJob"]
                                                       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=SageMaker.CreateInferenceRecommendationsJob" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"JobName\": \"\",\n  \"JobType\": \"\",\n  \"RoleArn\": \"\",\n  \"InputConfig\": \"\",\n  \"JobDescription\": \"\",\n  \"StoppingConditions\": \"\",\n  \"OutputConfig\": \"\",\n  \"Tags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateInferenceRecommendationsJob",
  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([
    'JobName' => '',
    'JobType' => '',
    'RoleArn' => '',
    'InputConfig' => '',
    'JobDescription' => '',
    'StoppingConditions' => '',
    'OutputConfig' => '',
    '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=SageMaker.CreateInferenceRecommendationsJob', [
  'body' => '{
  "JobName": "",
  "JobType": "",
  "RoleArn": "",
  "InputConfig": "",
  "JobDescription": "",
  "StoppingConditions": "",
  "OutputConfig": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'JobName' => '',
  'JobType' => '',
  'RoleArn' => '',
  'InputConfig' => '',
  'JobDescription' => '',
  'StoppingConditions' => '',
  'OutputConfig' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'JobName' => '',
  'JobType' => '',
  'RoleArn' => '',
  'InputConfig' => '',
  'JobDescription' => '',
  'StoppingConditions' => '',
  'OutputConfig' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateInferenceRecommendationsJob');
$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=SageMaker.CreateInferenceRecommendationsJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "JobName": "",
  "JobType": "",
  "RoleArn": "",
  "InputConfig": "",
  "JobDescription": "",
  "StoppingConditions": "",
  "OutputConfig": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateInferenceRecommendationsJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "JobName": "",
  "JobType": "",
  "RoleArn": "",
  "InputConfig": "",
  "JobDescription": "",
  "StoppingConditions": "",
  "OutputConfig": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"JobName\": \"\",\n  \"JobType\": \"\",\n  \"RoleArn\": \"\",\n  \"InputConfig\": \"\",\n  \"JobDescription\": \"\",\n  \"StoppingConditions\": \"\",\n  \"OutputConfig\": \"\",\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=SageMaker.CreateInferenceRecommendationsJob"

payload = {
    "JobName": "",
    "JobType": "",
    "RoleArn": "",
    "InputConfig": "",
    "JobDescription": "",
    "StoppingConditions": "",
    "OutputConfig": "",
    "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=SageMaker.CreateInferenceRecommendationsJob"

payload <- "{\n  \"JobName\": \"\",\n  \"JobType\": \"\",\n  \"RoleArn\": \"\",\n  \"InputConfig\": \"\",\n  \"JobDescription\": \"\",\n  \"StoppingConditions\": \"\",\n  \"OutputConfig\": \"\",\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=SageMaker.CreateInferenceRecommendationsJob")

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  \"JobName\": \"\",\n  \"JobType\": \"\",\n  \"RoleArn\": \"\",\n  \"InputConfig\": \"\",\n  \"JobDescription\": \"\",\n  \"StoppingConditions\": \"\",\n  \"OutputConfig\": \"\",\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  \"JobName\": \"\",\n  \"JobType\": \"\",\n  \"RoleArn\": \"\",\n  \"InputConfig\": \"\",\n  \"JobDescription\": \"\",\n  \"StoppingConditions\": \"\",\n  \"OutputConfig\": \"\",\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=SageMaker.CreateInferenceRecommendationsJob";

    let payload = json!({
        "JobName": "",
        "JobType": "",
        "RoleArn": "",
        "InputConfig": "",
        "JobDescription": "",
        "StoppingConditions": "",
        "OutputConfig": "",
        "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);
}

echo '{
  "JobName": "",
  "JobType": "",
  "RoleArn": "",
  "InputConfig": "",
  "JobDescription": "",
  "StoppingConditions": "",
  "OutputConfig": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateInferenceRecommendationsJob' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "JobName": "",\n  "JobType": "",\n  "RoleArn": "",\n  "InputConfig": "",\n  "JobDescription": "",\n  "StoppingConditions": "",\n  "OutputConfig": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateInferenceRecommendationsJob'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "JobName": "",
  "JobType": "",
  "RoleArn": "",
  "InputConfig": "",
  "JobDescription": "",
  "StoppingConditions": "",
  "OutputConfig": "",
  "Tags": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

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

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  \"LabelingJobName\": \"\",\n  \"LabelAttributeName\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"LabelCategoryConfigS3Uri\": \"\",\n  \"StoppingConditions\": \"\",\n  \"LabelingJobAlgorithmsConfig\": \"\",\n  \"HumanTaskConfig\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateLabelingJob" {:headers {:x-amz-target ""}
                                                                                      :content-type :json
                                                                                      :form-params {:LabelingJobName ""
                                                                                                    :LabelAttributeName ""
                                                                                                    :InputConfig ""
                                                                                                    :OutputConfig ""
                                                                                                    :RoleArn ""
                                                                                                    :LabelCategoryConfigS3Uri ""
                                                                                                    :StoppingConditions ""
                                                                                                    :LabelingJobAlgorithmsConfig ""
                                                                                                    :HumanTaskConfig ""
                                                                                                    :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateLabelingJob"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"LabelingJobName\": \"\",\n  \"LabelAttributeName\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"LabelCategoryConfigS3Uri\": \"\",\n  \"StoppingConditions\": \"\",\n  \"LabelingJobAlgorithmsConfig\": \"\",\n  \"HumanTaskConfig\": \"\",\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=SageMaker.CreateLabelingJob"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"LabelingJobName\": \"\",\n  \"LabelAttributeName\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"LabelCategoryConfigS3Uri\": \"\",\n  \"StoppingConditions\": \"\",\n  \"LabelingJobAlgorithmsConfig\": \"\",\n  \"HumanTaskConfig\": \"\",\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=SageMaker.CreateLabelingJob");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"LabelingJobName\": \"\",\n  \"LabelAttributeName\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"LabelCategoryConfigS3Uri\": \"\",\n  \"StoppingConditions\": \"\",\n  \"LabelingJobAlgorithmsConfig\": \"\",\n  \"HumanTaskConfig\": \"\",\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=SageMaker.CreateLabelingJob"

	payload := strings.NewReader("{\n  \"LabelingJobName\": \"\",\n  \"LabelAttributeName\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"LabelCategoryConfigS3Uri\": \"\",\n  \"StoppingConditions\": \"\",\n  \"LabelingJobAlgorithmsConfig\": \"\",\n  \"HumanTaskConfig\": \"\",\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: 253

{
  "LabelingJobName": "",
  "LabelAttributeName": "",
  "InputConfig": "",
  "OutputConfig": "",
  "RoleArn": "",
  "LabelCategoryConfigS3Uri": "",
  "StoppingConditions": "",
  "LabelingJobAlgorithmsConfig": "",
  "HumanTaskConfig": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateLabelingJob")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"LabelingJobName\": \"\",\n  \"LabelAttributeName\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"LabelCategoryConfigS3Uri\": \"\",\n  \"StoppingConditions\": \"\",\n  \"LabelingJobAlgorithmsConfig\": \"\",\n  \"HumanTaskConfig\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateLabelingJob"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"LabelingJobName\": \"\",\n  \"LabelAttributeName\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"LabelCategoryConfigS3Uri\": \"\",\n  \"StoppingConditions\": \"\",\n  \"LabelingJobAlgorithmsConfig\": \"\",\n  \"HumanTaskConfig\": \"\",\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  \"LabelingJobName\": \"\",\n  \"LabelAttributeName\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"LabelCategoryConfigS3Uri\": \"\",\n  \"StoppingConditions\": \"\",\n  \"LabelingJobAlgorithmsConfig\": \"\",\n  \"HumanTaskConfig\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateLabelingJob")
  .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=SageMaker.CreateLabelingJob")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"LabelingJobName\": \"\",\n  \"LabelAttributeName\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"LabelCategoryConfigS3Uri\": \"\",\n  \"StoppingConditions\": \"\",\n  \"LabelingJobAlgorithmsConfig\": \"\",\n  \"HumanTaskConfig\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  LabelingJobName: '',
  LabelAttributeName: '',
  InputConfig: '',
  OutputConfig: '',
  RoleArn: '',
  LabelCategoryConfigS3Uri: '',
  StoppingConditions: '',
  LabelingJobAlgorithmsConfig: '',
  HumanTaskConfig: '',
  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=SageMaker.CreateLabelingJob');
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=SageMaker.CreateLabelingJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    LabelingJobName: '',
    LabelAttributeName: '',
    InputConfig: '',
    OutputConfig: '',
    RoleArn: '',
    LabelCategoryConfigS3Uri: '',
    StoppingConditions: '',
    LabelingJobAlgorithmsConfig: '',
    HumanTaskConfig: '',
    Tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateLabelingJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"LabelingJobName":"","LabelAttributeName":"","InputConfig":"","OutputConfig":"","RoleArn":"","LabelCategoryConfigS3Uri":"","StoppingConditions":"","LabelingJobAlgorithmsConfig":"","HumanTaskConfig":"","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=SageMaker.CreateLabelingJob',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "LabelingJobName": "",\n  "LabelAttributeName": "",\n  "InputConfig": "",\n  "OutputConfig": "",\n  "RoleArn": "",\n  "LabelCategoryConfigS3Uri": "",\n  "StoppingConditions": "",\n  "LabelingJobAlgorithmsConfig": "",\n  "HumanTaskConfig": "",\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  \"LabelingJobName\": \"\",\n  \"LabelAttributeName\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"LabelCategoryConfigS3Uri\": \"\",\n  \"StoppingConditions\": \"\",\n  \"LabelingJobAlgorithmsConfig\": \"\",\n  \"HumanTaskConfig\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateLabelingJob")
  .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({
  LabelingJobName: '',
  LabelAttributeName: '',
  InputConfig: '',
  OutputConfig: '',
  RoleArn: '',
  LabelCategoryConfigS3Uri: '',
  StoppingConditions: '',
  LabelingJobAlgorithmsConfig: '',
  HumanTaskConfig: '',
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateLabelingJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    LabelingJobName: '',
    LabelAttributeName: '',
    InputConfig: '',
    OutputConfig: '',
    RoleArn: '',
    LabelCategoryConfigS3Uri: '',
    StoppingConditions: '',
    LabelingJobAlgorithmsConfig: '',
    HumanTaskConfig: '',
    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=SageMaker.CreateLabelingJob');

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

req.type('json');
req.send({
  LabelingJobName: '',
  LabelAttributeName: '',
  InputConfig: '',
  OutputConfig: '',
  RoleArn: '',
  LabelCategoryConfigS3Uri: '',
  StoppingConditions: '',
  LabelingJobAlgorithmsConfig: '',
  HumanTaskConfig: '',
  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=SageMaker.CreateLabelingJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    LabelingJobName: '',
    LabelAttributeName: '',
    InputConfig: '',
    OutputConfig: '',
    RoleArn: '',
    LabelCategoryConfigS3Uri: '',
    StoppingConditions: '',
    LabelingJobAlgorithmsConfig: '',
    HumanTaskConfig: '',
    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=SageMaker.CreateLabelingJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"LabelingJobName":"","LabelAttributeName":"","InputConfig":"","OutputConfig":"","RoleArn":"","LabelCategoryConfigS3Uri":"","StoppingConditions":"","LabelingJobAlgorithmsConfig":"","HumanTaskConfig":"","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 = @{ @"LabelingJobName": @"",
                              @"LabelAttributeName": @"",
                              @"InputConfig": @"",
                              @"OutputConfig": @"",
                              @"RoleArn": @"",
                              @"LabelCategoryConfigS3Uri": @"",
                              @"StoppingConditions": @"",
                              @"LabelingJobAlgorithmsConfig": @"",
                              @"HumanTaskConfig": @"",
                              @"Tags": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreateLabelingJob"]
                                                       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=SageMaker.CreateLabelingJob" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"LabelingJobName\": \"\",\n  \"LabelAttributeName\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"LabelCategoryConfigS3Uri\": \"\",\n  \"StoppingConditions\": \"\",\n  \"LabelingJobAlgorithmsConfig\": \"\",\n  \"HumanTaskConfig\": \"\",\n  \"Tags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateLabelingJob",
  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([
    'LabelingJobName' => '',
    'LabelAttributeName' => '',
    'InputConfig' => '',
    'OutputConfig' => '',
    'RoleArn' => '',
    'LabelCategoryConfigS3Uri' => '',
    'StoppingConditions' => '',
    'LabelingJobAlgorithmsConfig' => '',
    'HumanTaskConfig' => '',
    '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=SageMaker.CreateLabelingJob', [
  'body' => '{
  "LabelingJobName": "",
  "LabelAttributeName": "",
  "InputConfig": "",
  "OutputConfig": "",
  "RoleArn": "",
  "LabelCategoryConfigS3Uri": "",
  "StoppingConditions": "",
  "LabelingJobAlgorithmsConfig": "",
  "HumanTaskConfig": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'LabelingJobName' => '',
  'LabelAttributeName' => '',
  'InputConfig' => '',
  'OutputConfig' => '',
  'RoleArn' => '',
  'LabelCategoryConfigS3Uri' => '',
  'StoppingConditions' => '',
  'LabelingJobAlgorithmsConfig' => '',
  'HumanTaskConfig' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'LabelingJobName' => '',
  'LabelAttributeName' => '',
  'InputConfig' => '',
  'OutputConfig' => '',
  'RoleArn' => '',
  'LabelCategoryConfigS3Uri' => '',
  'StoppingConditions' => '',
  'LabelingJobAlgorithmsConfig' => '',
  'HumanTaskConfig' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateLabelingJob');
$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=SageMaker.CreateLabelingJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "LabelingJobName": "",
  "LabelAttributeName": "",
  "InputConfig": "",
  "OutputConfig": "",
  "RoleArn": "",
  "LabelCategoryConfigS3Uri": "",
  "StoppingConditions": "",
  "LabelingJobAlgorithmsConfig": "",
  "HumanTaskConfig": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateLabelingJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "LabelingJobName": "",
  "LabelAttributeName": "",
  "InputConfig": "",
  "OutputConfig": "",
  "RoleArn": "",
  "LabelCategoryConfigS3Uri": "",
  "StoppingConditions": "",
  "LabelingJobAlgorithmsConfig": "",
  "HumanTaskConfig": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"LabelingJobName\": \"\",\n  \"LabelAttributeName\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"LabelCategoryConfigS3Uri\": \"\",\n  \"StoppingConditions\": \"\",\n  \"LabelingJobAlgorithmsConfig\": \"\",\n  \"HumanTaskConfig\": \"\",\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=SageMaker.CreateLabelingJob"

payload = {
    "LabelingJobName": "",
    "LabelAttributeName": "",
    "InputConfig": "",
    "OutputConfig": "",
    "RoleArn": "",
    "LabelCategoryConfigS3Uri": "",
    "StoppingConditions": "",
    "LabelingJobAlgorithmsConfig": "",
    "HumanTaskConfig": "",
    "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=SageMaker.CreateLabelingJob"

payload <- "{\n  \"LabelingJobName\": \"\",\n  \"LabelAttributeName\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"LabelCategoryConfigS3Uri\": \"\",\n  \"StoppingConditions\": \"\",\n  \"LabelingJobAlgorithmsConfig\": \"\",\n  \"HumanTaskConfig\": \"\",\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=SageMaker.CreateLabelingJob")

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  \"LabelingJobName\": \"\",\n  \"LabelAttributeName\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"LabelCategoryConfigS3Uri\": \"\",\n  \"StoppingConditions\": \"\",\n  \"LabelingJobAlgorithmsConfig\": \"\",\n  \"HumanTaskConfig\": \"\",\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  \"LabelingJobName\": \"\",\n  \"LabelAttributeName\": \"\",\n  \"InputConfig\": \"\",\n  \"OutputConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"LabelCategoryConfigS3Uri\": \"\",\n  \"StoppingConditions\": \"\",\n  \"LabelingJobAlgorithmsConfig\": \"\",\n  \"HumanTaskConfig\": \"\",\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=SageMaker.CreateLabelingJob";

    let payload = json!({
        "LabelingJobName": "",
        "LabelAttributeName": "",
        "InputConfig": "",
        "OutputConfig": "",
        "RoleArn": "",
        "LabelCategoryConfigS3Uri": "",
        "StoppingConditions": "",
        "LabelingJobAlgorithmsConfig": "",
        "HumanTaskConfig": "",
        "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);
}

echo '{
  "LabelingJobName": "",
  "LabelAttributeName": "",
  "InputConfig": "",
  "OutputConfig": "",
  "RoleArn": "",
  "LabelCategoryConfigS3Uri": "",
  "StoppingConditions": "",
  "LabelingJobAlgorithmsConfig": "",
  "HumanTaskConfig": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateLabelingJob' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "LabelingJobName": "",\n  "LabelAttributeName": "",\n  "InputConfig": "",\n  "OutputConfig": "",\n  "RoleArn": "",\n  "LabelCategoryConfigS3Uri": "",\n  "StoppingConditions": "",\n  "LabelingJobAlgorithmsConfig": "",\n  "HumanTaskConfig": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateLabelingJob'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "LabelingJobName": "",
  "LabelAttributeName": "",
  "InputConfig": "",
  "OutputConfig": "",
  "RoleArn": "",
  "LabelCategoryConfigS3Uri": "",
  "StoppingConditions": "",
  "LabelingJobAlgorithmsConfig": "",
  "HumanTaskConfig": "",
  "Tags": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"ModelName\": \"\",\n  \"PrimaryContainer\": \"\",\n  \"Containers\": \"\",\n  \"InferenceExecutionConfig\": \"\",\n  \"ExecutionRoleArn\": \"\",\n  \"Tags\": \"\",\n  \"VpcConfig\": \"\",\n  \"EnableNetworkIsolation\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModel" {:headers {:x-amz-target ""}
                                                                                :content-type :json
                                                                                :form-params {:ModelName ""
                                                                                              :PrimaryContainer ""
                                                                                              :Containers ""
                                                                                              :InferenceExecutionConfig ""
                                                                                              :ExecutionRoleArn ""
                                                                                              :Tags ""
                                                                                              :VpcConfig ""
                                                                                              :EnableNetworkIsolation ""}})

require "http/client"

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

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"ModelName\": \"\",\n  \"PrimaryContainer\": \"\",\n  \"Containers\": \"\",\n  \"InferenceExecutionConfig\": \"\",\n  \"ExecutionRoleArn\": \"\",\n  \"Tags\": \"\",\n  \"VpcConfig\": \"\",\n  \"EnableNetworkIsolation\": \"\"\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: 192

{
  "ModelName": "",
  "PrimaryContainer": "",
  "Containers": "",
  "InferenceExecutionConfig": "",
  "ExecutionRoleArn": "",
  "Tags": "",
  "VpcConfig": "",
  "EnableNetworkIsolation": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModel")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ModelName\": \"\",\n  \"PrimaryContainer\": \"\",\n  \"Containers\": \"\",\n  \"InferenceExecutionConfig\": \"\",\n  \"ExecutionRoleArn\": \"\",\n  \"Tags\": \"\",\n  \"VpcConfig\": \"\",\n  \"EnableNetworkIsolation\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModel"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ModelName\": \"\",\n  \"PrimaryContainer\": \"\",\n  \"Containers\": \"\",\n  \"InferenceExecutionConfig\": \"\",\n  \"ExecutionRoleArn\": \"\",\n  \"Tags\": \"\",\n  \"VpcConfig\": \"\",\n  \"EnableNetworkIsolation\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ModelName\": \"\",\n  \"PrimaryContainer\": \"\",\n  \"Containers\": \"\",\n  \"InferenceExecutionConfig\": \"\",\n  \"ExecutionRoleArn\": \"\",\n  \"Tags\": \"\",\n  \"VpcConfig\": \"\",\n  \"EnableNetworkIsolation\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModel")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModel")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ModelName\": \"\",\n  \"PrimaryContainer\": \"\",\n  \"Containers\": \"\",\n  \"InferenceExecutionConfig\": \"\",\n  \"ExecutionRoleArn\": \"\",\n  \"Tags\": \"\",\n  \"VpcConfig\": \"\",\n  \"EnableNetworkIsolation\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ModelName: '',
  PrimaryContainer: '',
  Containers: '',
  InferenceExecutionConfig: '',
  ExecutionRoleArn: '',
  Tags: '',
  VpcConfig: '',
  EnableNetworkIsolation: ''
});

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModel',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ModelName: '',
    PrimaryContainer: '',
    Containers: '',
    InferenceExecutionConfig: '',
    ExecutionRoleArn: '',
    Tags: '',
    VpcConfig: '',
    EnableNetworkIsolation: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModel';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ModelName":"","PrimaryContainer":"","Containers":"","InferenceExecutionConfig":"","ExecutionRoleArn":"","Tags":"","VpcConfig":"","EnableNetworkIsolation":""}'
};

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=SageMaker.CreateModel',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ModelName": "",\n  "PrimaryContainer": "",\n  "Containers": "",\n  "InferenceExecutionConfig": "",\n  "ExecutionRoleArn": "",\n  "Tags": "",\n  "VpcConfig": "",\n  "EnableNetworkIsolation": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ModelName\": \"\",\n  \"PrimaryContainer\": \"\",\n  \"Containers\": \"\",\n  \"InferenceExecutionConfig\": \"\",\n  \"ExecutionRoleArn\": \"\",\n  \"Tags\": \"\",\n  \"VpcConfig\": \"\",\n  \"EnableNetworkIsolation\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModel")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  ModelName: '',
  PrimaryContainer: '',
  Containers: '',
  InferenceExecutionConfig: '',
  ExecutionRoleArn: '',
  Tags: '',
  VpcConfig: '',
  EnableNetworkIsolation: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModel',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ModelName: '',
    PrimaryContainer: '',
    Containers: '',
    InferenceExecutionConfig: '',
    ExecutionRoleArn: '',
    Tags: '',
    VpcConfig: '',
    EnableNetworkIsolation: ''
  },
  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=SageMaker.CreateModel');

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

req.type('json');
req.send({
  ModelName: '',
  PrimaryContainer: '',
  Containers: '',
  InferenceExecutionConfig: '',
  ExecutionRoleArn: '',
  Tags: '',
  VpcConfig: '',
  EnableNetworkIsolation: ''
});

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=SageMaker.CreateModel',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ModelName: '',
    PrimaryContainer: '',
    Containers: '',
    InferenceExecutionConfig: '',
    ExecutionRoleArn: '',
    Tags: '',
    VpcConfig: '',
    EnableNetworkIsolation: ''
  }
};

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=SageMaker.CreateModel';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ModelName":"","PrimaryContainer":"","Containers":"","InferenceExecutionConfig":"","ExecutionRoleArn":"","Tags":"","VpcConfig":"","EnableNetworkIsolation":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ModelName": @"",
                              @"PrimaryContainer": @"",
                              @"Containers": @"",
                              @"InferenceExecutionConfig": @"",
                              @"ExecutionRoleArn": @"",
                              @"Tags": @"",
                              @"VpcConfig": @"",
                              @"EnableNetworkIsolation": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModel" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ModelName\": \"\",\n  \"PrimaryContainer\": \"\",\n  \"Containers\": \"\",\n  \"InferenceExecutionConfig\": \"\",\n  \"ExecutionRoleArn\": \"\",\n  \"Tags\": \"\",\n  \"VpcConfig\": \"\",\n  \"EnableNetworkIsolation\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModel",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'ModelName' => '',
    'PrimaryContainer' => '',
    'Containers' => '',
    'InferenceExecutionConfig' => '',
    'ExecutionRoleArn' => '',
    'Tags' => '',
    'VpcConfig' => '',
    'EnableNetworkIsolation' => ''
  ]),
  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=SageMaker.CreateModel', [
  'body' => '{
  "ModelName": "",
  "PrimaryContainer": "",
  "Containers": "",
  "InferenceExecutionConfig": "",
  "ExecutionRoleArn": "",
  "Tags": "",
  "VpcConfig": "",
  "EnableNetworkIsolation": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ModelName' => '',
  'PrimaryContainer' => '',
  'Containers' => '',
  'InferenceExecutionConfig' => '',
  'ExecutionRoleArn' => '',
  'Tags' => '',
  'VpcConfig' => '',
  'EnableNetworkIsolation' => ''
]));

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

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

append(json_encode([
  'ModelName' => '',
  'PrimaryContainer' => '',
  'Containers' => '',
  'InferenceExecutionConfig' => '',
  'ExecutionRoleArn' => '',
  'Tags' => '',
  'VpcConfig' => '',
  'EnableNetworkIsolation' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModel');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModel' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ModelName": "",
  "PrimaryContainer": "",
  "Containers": "",
  "InferenceExecutionConfig": "",
  "ExecutionRoleArn": "",
  "Tags": "",
  "VpcConfig": "",
  "EnableNetworkIsolation": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModel' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ModelName": "",
  "PrimaryContainer": "",
  "Containers": "",
  "InferenceExecutionConfig": "",
  "ExecutionRoleArn": "",
  "Tags": "",
  "VpcConfig": "",
  "EnableNetworkIsolation": ""
}'

import http.client

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

payload = "{\n  \"ModelName\": \"\",\n  \"PrimaryContainer\": \"\",\n  \"Containers\": \"\",\n  \"InferenceExecutionConfig\": \"\",\n  \"ExecutionRoleArn\": \"\",\n  \"Tags\": \"\",\n  \"VpcConfig\": \"\",\n  \"EnableNetworkIsolation\": \"\"\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=SageMaker.CreateModel"

payload = {
    "ModelName": "",
    "PrimaryContainer": "",
    "Containers": "",
    "InferenceExecutionConfig": "",
    "ExecutionRoleArn": "",
    "Tags": "",
    "VpcConfig": "",
    "EnableNetworkIsolation": ""
}
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=SageMaker.CreateModel"

payload <- "{\n  \"ModelName\": \"\",\n  \"PrimaryContainer\": \"\",\n  \"Containers\": \"\",\n  \"InferenceExecutionConfig\": \"\",\n  \"ExecutionRoleArn\": \"\",\n  \"Tags\": \"\",\n  \"VpcConfig\": \"\",\n  \"EnableNetworkIsolation\": \"\"\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=SageMaker.CreateModel")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"ModelName\": \"\",\n  \"PrimaryContainer\": \"\",\n  \"Containers\": \"\",\n  \"InferenceExecutionConfig\": \"\",\n  \"ExecutionRoleArn\": \"\",\n  \"Tags\": \"\",\n  \"VpcConfig\": \"\",\n  \"EnableNetworkIsolation\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"ModelName\": \"\",\n  \"PrimaryContainer\": \"\",\n  \"Containers\": \"\",\n  \"InferenceExecutionConfig\": \"\",\n  \"ExecutionRoleArn\": \"\",\n  \"Tags\": \"\",\n  \"VpcConfig\": \"\",\n  \"EnableNetworkIsolation\": \"\"\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=SageMaker.CreateModel";

    let payload = json!({
        "ModelName": "",
        "PrimaryContainer": "",
        "Containers": "",
        "InferenceExecutionConfig": "",
        "ExecutionRoleArn": "",
        "Tags": "",
        "VpcConfig": "",
        "EnableNetworkIsolation": ""
    });

    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);
}

echo '{
  "ModelName": "",
  "PrimaryContainer": "",
  "Containers": "",
  "InferenceExecutionConfig": "",
  "ExecutionRoleArn": "",
  "Tags": "",
  "VpcConfig": "",
  "EnableNetworkIsolation": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModel' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ModelName": "",\n  "PrimaryContainer": "",\n  "Containers": "",\n  "InferenceExecutionConfig": "",\n  "ExecutionRoleArn": "",\n  "Tags": "",\n  "VpcConfig": "",\n  "EnableNetworkIsolation": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModel'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ModelName": "",
  "PrimaryContainer": "",
  "Containers": "",
  "InferenceExecutionConfig": "",
  "ExecutionRoleArn": "",
  "Tags": "",
  "VpcConfig": "",
  "EnableNetworkIsolation": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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  \"JobDefinitionName\": \"\",\n  \"ModelBiasBaselineConfig\": \"\",\n  \"ModelBiasAppSpecification\": \"\",\n  \"ModelBiasJobInput\": \"\",\n  \"ModelBiasJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelBiasJobDefinition" {:headers {:x-amz-target ""}
                                                                                                 :content-type :json
                                                                                                 :form-params {:JobDefinitionName ""
                                                                                                               :ModelBiasBaselineConfig ""
                                                                                                               :ModelBiasAppSpecification ""
                                                                                                               :ModelBiasJobInput ""
                                                                                                               :ModelBiasJobOutputConfig {:MonitoringOutputs ""
                                                                                                                                          :KmsKeyId ""}
                                                                                                               :JobResources {:ClusterConfig ""}
                                                                                                               :NetworkConfig ""
                                                                                                               :RoleArn ""
                                                                                                               :StoppingCondition {:MaxRuntimeInSeconds ""}
                                                                                                               :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelBiasJobDefinition"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"JobDefinitionName\": \"\",\n  \"ModelBiasBaselineConfig\": \"\",\n  \"ModelBiasAppSpecification\": \"\",\n  \"ModelBiasJobInput\": \"\",\n  \"ModelBiasJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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=SageMaker.CreateModelBiasJobDefinition"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"JobDefinitionName\": \"\",\n  \"ModelBiasBaselineConfig\": \"\",\n  \"ModelBiasAppSpecification\": \"\",\n  \"ModelBiasJobInput\": \"\",\n  \"ModelBiasJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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=SageMaker.CreateModelBiasJobDefinition");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"JobDefinitionName\": \"\",\n  \"ModelBiasBaselineConfig\": \"\",\n  \"ModelBiasAppSpecification\": \"\",\n  \"ModelBiasJobInput\": \"\",\n  \"ModelBiasJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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=SageMaker.CreateModelBiasJobDefinition"

	payload := strings.NewReader("{\n  \"JobDefinitionName\": \"\",\n  \"ModelBiasBaselineConfig\": \"\",\n  \"ModelBiasAppSpecification\": \"\",\n  \"ModelBiasJobInput\": \"\",\n  \"ModelBiasJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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: 372

{
  "JobDefinitionName": "",
  "ModelBiasBaselineConfig": "",
  "ModelBiasAppSpecification": "",
  "ModelBiasJobInput": "",
  "ModelBiasJobOutputConfig": {
    "MonitoringOutputs": "",
    "KmsKeyId": ""
  },
  "JobResources": {
    "ClusterConfig": ""
  },
  "NetworkConfig": "",
  "RoleArn": "",
  "StoppingCondition": {
    "MaxRuntimeInSeconds": ""
  },
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelBiasJobDefinition")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"JobDefinitionName\": \"\",\n  \"ModelBiasBaselineConfig\": \"\",\n  \"ModelBiasAppSpecification\": \"\",\n  \"ModelBiasJobInput\": \"\",\n  \"ModelBiasJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelBiasJobDefinition"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"JobDefinitionName\": \"\",\n  \"ModelBiasBaselineConfig\": \"\",\n  \"ModelBiasAppSpecification\": \"\",\n  \"ModelBiasJobInput\": \"\",\n  \"ModelBiasJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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  \"JobDefinitionName\": \"\",\n  \"ModelBiasBaselineConfig\": \"\",\n  \"ModelBiasAppSpecification\": \"\",\n  \"ModelBiasJobInput\": \"\",\n  \"ModelBiasJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelBiasJobDefinition")
  .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=SageMaker.CreateModelBiasJobDefinition")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"JobDefinitionName\": \"\",\n  \"ModelBiasBaselineConfig\": \"\",\n  \"ModelBiasAppSpecification\": \"\",\n  \"ModelBiasJobInput\": \"\",\n  \"ModelBiasJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  JobDefinitionName: '',
  ModelBiasBaselineConfig: '',
  ModelBiasAppSpecification: '',
  ModelBiasJobInput: '',
  ModelBiasJobOutputConfig: {
    MonitoringOutputs: '',
    KmsKeyId: ''
  },
  JobResources: {
    ClusterConfig: ''
  },
  NetworkConfig: '',
  RoleArn: '',
  StoppingCondition: {
    MaxRuntimeInSeconds: ''
  },
  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=SageMaker.CreateModelBiasJobDefinition');
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=SageMaker.CreateModelBiasJobDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    JobDefinitionName: '',
    ModelBiasBaselineConfig: '',
    ModelBiasAppSpecification: '',
    ModelBiasJobInput: '',
    ModelBiasJobOutputConfig: {MonitoringOutputs: '', KmsKeyId: ''},
    JobResources: {ClusterConfig: ''},
    NetworkConfig: '',
    RoleArn: '',
    StoppingCondition: {MaxRuntimeInSeconds: ''},
    Tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelBiasJobDefinition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"JobDefinitionName":"","ModelBiasBaselineConfig":"","ModelBiasAppSpecification":"","ModelBiasJobInput":"","ModelBiasJobOutputConfig":{"MonitoringOutputs":"","KmsKeyId":""},"JobResources":{"ClusterConfig":""},"NetworkConfig":"","RoleArn":"","StoppingCondition":{"MaxRuntimeInSeconds":""},"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=SageMaker.CreateModelBiasJobDefinition',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "JobDefinitionName": "",\n  "ModelBiasBaselineConfig": "",\n  "ModelBiasAppSpecification": "",\n  "ModelBiasJobInput": "",\n  "ModelBiasJobOutputConfig": {\n    "MonitoringOutputs": "",\n    "KmsKeyId": ""\n  },\n  "JobResources": {\n    "ClusterConfig": ""\n  },\n  "NetworkConfig": "",\n  "RoleArn": "",\n  "StoppingCondition": {\n    "MaxRuntimeInSeconds": ""\n  },\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  \"JobDefinitionName\": \"\",\n  \"ModelBiasBaselineConfig\": \"\",\n  \"ModelBiasAppSpecification\": \"\",\n  \"ModelBiasJobInput\": \"\",\n  \"ModelBiasJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelBiasJobDefinition")
  .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({
  JobDefinitionName: '',
  ModelBiasBaselineConfig: '',
  ModelBiasAppSpecification: '',
  ModelBiasJobInput: '',
  ModelBiasJobOutputConfig: {MonitoringOutputs: '', KmsKeyId: ''},
  JobResources: {ClusterConfig: ''},
  NetworkConfig: '',
  RoleArn: '',
  StoppingCondition: {MaxRuntimeInSeconds: ''},
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelBiasJobDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    JobDefinitionName: '',
    ModelBiasBaselineConfig: '',
    ModelBiasAppSpecification: '',
    ModelBiasJobInput: '',
    ModelBiasJobOutputConfig: {MonitoringOutputs: '', KmsKeyId: ''},
    JobResources: {ClusterConfig: ''},
    NetworkConfig: '',
    RoleArn: '',
    StoppingCondition: {MaxRuntimeInSeconds: ''},
    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=SageMaker.CreateModelBiasJobDefinition');

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

req.type('json');
req.send({
  JobDefinitionName: '',
  ModelBiasBaselineConfig: '',
  ModelBiasAppSpecification: '',
  ModelBiasJobInput: '',
  ModelBiasJobOutputConfig: {
    MonitoringOutputs: '',
    KmsKeyId: ''
  },
  JobResources: {
    ClusterConfig: ''
  },
  NetworkConfig: '',
  RoleArn: '',
  StoppingCondition: {
    MaxRuntimeInSeconds: ''
  },
  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=SageMaker.CreateModelBiasJobDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    JobDefinitionName: '',
    ModelBiasBaselineConfig: '',
    ModelBiasAppSpecification: '',
    ModelBiasJobInput: '',
    ModelBiasJobOutputConfig: {MonitoringOutputs: '', KmsKeyId: ''},
    JobResources: {ClusterConfig: ''},
    NetworkConfig: '',
    RoleArn: '',
    StoppingCondition: {MaxRuntimeInSeconds: ''},
    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=SageMaker.CreateModelBiasJobDefinition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"JobDefinitionName":"","ModelBiasBaselineConfig":"","ModelBiasAppSpecification":"","ModelBiasJobInput":"","ModelBiasJobOutputConfig":{"MonitoringOutputs":"","KmsKeyId":""},"JobResources":{"ClusterConfig":""},"NetworkConfig":"","RoleArn":"","StoppingCondition":{"MaxRuntimeInSeconds":""},"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 = @{ @"JobDefinitionName": @"",
                              @"ModelBiasBaselineConfig": @"",
                              @"ModelBiasAppSpecification": @"",
                              @"ModelBiasJobInput": @"",
                              @"ModelBiasJobOutputConfig": @{ @"MonitoringOutputs": @"", @"KmsKeyId": @"" },
                              @"JobResources": @{ @"ClusterConfig": @"" },
                              @"NetworkConfig": @"",
                              @"RoleArn": @"",
                              @"StoppingCondition": @{ @"MaxRuntimeInSeconds": @"" },
                              @"Tags": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelBiasJobDefinition"]
                                                       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=SageMaker.CreateModelBiasJobDefinition" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"JobDefinitionName\": \"\",\n  \"ModelBiasBaselineConfig\": \"\",\n  \"ModelBiasAppSpecification\": \"\",\n  \"ModelBiasJobInput\": \"\",\n  \"ModelBiasJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\n  \"Tags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelBiasJobDefinition",
  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([
    'JobDefinitionName' => '',
    'ModelBiasBaselineConfig' => '',
    'ModelBiasAppSpecification' => '',
    'ModelBiasJobInput' => '',
    'ModelBiasJobOutputConfig' => [
        'MonitoringOutputs' => '',
        'KmsKeyId' => ''
    ],
    'JobResources' => [
        'ClusterConfig' => ''
    ],
    'NetworkConfig' => '',
    'RoleArn' => '',
    'StoppingCondition' => [
        'MaxRuntimeInSeconds' => ''
    ],
    '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=SageMaker.CreateModelBiasJobDefinition', [
  'body' => '{
  "JobDefinitionName": "",
  "ModelBiasBaselineConfig": "",
  "ModelBiasAppSpecification": "",
  "ModelBiasJobInput": "",
  "ModelBiasJobOutputConfig": {
    "MonitoringOutputs": "",
    "KmsKeyId": ""
  },
  "JobResources": {
    "ClusterConfig": ""
  },
  "NetworkConfig": "",
  "RoleArn": "",
  "StoppingCondition": {
    "MaxRuntimeInSeconds": ""
  },
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'JobDefinitionName' => '',
  'ModelBiasBaselineConfig' => '',
  'ModelBiasAppSpecification' => '',
  'ModelBiasJobInput' => '',
  'ModelBiasJobOutputConfig' => [
    'MonitoringOutputs' => '',
    'KmsKeyId' => ''
  ],
  'JobResources' => [
    'ClusterConfig' => ''
  ],
  'NetworkConfig' => '',
  'RoleArn' => '',
  'StoppingCondition' => [
    'MaxRuntimeInSeconds' => ''
  ],
  'Tags' => ''
]));

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

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

append(json_encode([
  'JobDefinitionName' => '',
  'ModelBiasBaselineConfig' => '',
  'ModelBiasAppSpecification' => '',
  'ModelBiasJobInput' => '',
  'ModelBiasJobOutputConfig' => [
    'MonitoringOutputs' => '',
    'KmsKeyId' => ''
  ],
  'JobResources' => [
    'ClusterConfig' => ''
  ],
  'NetworkConfig' => '',
  'RoleArn' => '',
  'StoppingCondition' => [
    'MaxRuntimeInSeconds' => ''
  ],
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelBiasJobDefinition');
$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=SageMaker.CreateModelBiasJobDefinition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "JobDefinitionName": "",
  "ModelBiasBaselineConfig": "",
  "ModelBiasAppSpecification": "",
  "ModelBiasJobInput": "",
  "ModelBiasJobOutputConfig": {
    "MonitoringOutputs": "",
    "KmsKeyId": ""
  },
  "JobResources": {
    "ClusterConfig": ""
  },
  "NetworkConfig": "",
  "RoleArn": "",
  "StoppingCondition": {
    "MaxRuntimeInSeconds": ""
  },
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelBiasJobDefinition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "JobDefinitionName": "",
  "ModelBiasBaselineConfig": "",
  "ModelBiasAppSpecification": "",
  "ModelBiasJobInput": "",
  "ModelBiasJobOutputConfig": {
    "MonitoringOutputs": "",
    "KmsKeyId": ""
  },
  "JobResources": {
    "ClusterConfig": ""
  },
  "NetworkConfig": "",
  "RoleArn": "",
  "StoppingCondition": {
    "MaxRuntimeInSeconds": ""
  },
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"JobDefinitionName\": \"\",\n  \"ModelBiasBaselineConfig\": \"\",\n  \"ModelBiasAppSpecification\": \"\",\n  \"ModelBiasJobInput\": \"\",\n  \"ModelBiasJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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=SageMaker.CreateModelBiasJobDefinition"

payload = {
    "JobDefinitionName": "",
    "ModelBiasBaselineConfig": "",
    "ModelBiasAppSpecification": "",
    "ModelBiasJobInput": "",
    "ModelBiasJobOutputConfig": {
        "MonitoringOutputs": "",
        "KmsKeyId": ""
    },
    "JobResources": { "ClusterConfig": "" },
    "NetworkConfig": "",
    "RoleArn": "",
    "StoppingCondition": { "MaxRuntimeInSeconds": "" },
    "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=SageMaker.CreateModelBiasJobDefinition"

payload <- "{\n  \"JobDefinitionName\": \"\",\n  \"ModelBiasBaselineConfig\": \"\",\n  \"ModelBiasAppSpecification\": \"\",\n  \"ModelBiasJobInput\": \"\",\n  \"ModelBiasJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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=SageMaker.CreateModelBiasJobDefinition")

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  \"JobDefinitionName\": \"\",\n  \"ModelBiasBaselineConfig\": \"\",\n  \"ModelBiasAppSpecification\": \"\",\n  \"ModelBiasJobInput\": \"\",\n  \"ModelBiasJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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  \"JobDefinitionName\": \"\",\n  \"ModelBiasBaselineConfig\": \"\",\n  \"ModelBiasAppSpecification\": \"\",\n  \"ModelBiasJobInput\": \"\",\n  \"ModelBiasJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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=SageMaker.CreateModelBiasJobDefinition";

    let payload = json!({
        "JobDefinitionName": "",
        "ModelBiasBaselineConfig": "",
        "ModelBiasAppSpecification": "",
        "ModelBiasJobInput": "",
        "ModelBiasJobOutputConfig": json!({
            "MonitoringOutputs": "",
            "KmsKeyId": ""
        }),
        "JobResources": json!({"ClusterConfig": ""}),
        "NetworkConfig": "",
        "RoleArn": "",
        "StoppingCondition": json!({"MaxRuntimeInSeconds": ""}),
        "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);
}

echo '{
  "JobDefinitionName": "",
  "ModelBiasBaselineConfig": "",
  "ModelBiasAppSpecification": "",
  "ModelBiasJobInput": "",
  "ModelBiasJobOutputConfig": {
    "MonitoringOutputs": "",
    "KmsKeyId": ""
  },
  "JobResources": {
    "ClusterConfig": ""
  },
  "NetworkConfig": "",
  "RoleArn": "",
  "StoppingCondition": {
    "MaxRuntimeInSeconds": ""
  },
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelBiasJobDefinition' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "JobDefinitionName": "",\n  "ModelBiasBaselineConfig": "",\n  "ModelBiasAppSpecification": "",\n  "ModelBiasJobInput": "",\n  "ModelBiasJobOutputConfig": {\n    "MonitoringOutputs": "",\n    "KmsKeyId": ""\n  },\n  "JobResources": {\n    "ClusterConfig": ""\n  },\n  "NetworkConfig": "",\n  "RoleArn": "",\n  "StoppingCondition": {\n    "MaxRuntimeInSeconds": ""\n  },\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelBiasJobDefinition'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "JobDefinitionName": "",
  "ModelBiasBaselineConfig": "",
  "ModelBiasAppSpecification": "",
  "ModelBiasJobInput": "",
  "ModelBiasJobOutputConfig": [
    "MonitoringOutputs": "",
    "KmsKeyId": ""
  ],
  "JobResources": ["ClusterConfig": ""],
  "NetworkConfig": "",
  "RoleArn": "",
  "StoppingCondition": ["MaxRuntimeInSeconds": ""],
  "Tags": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

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

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  \"ModelCardName\": \"\",\n  \"SecurityConfig\": \"\",\n  \"Content\": \"\",\n  \"ModelCardStatus\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelCard" {:headers {:x-amz-target ""}
                                                                                    :content-type :json
                                                                                    :form-params {:ModelCardName ""
                                                                                                  :SecurityConfig ""
                                                                                                  :Content ""
                                                                                                  :ModelCardStatus ""
                                                                                                  :Tags ""}})

require "http/client"

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

	payload := strings.NewReader("{\n  \"ModelCardName\": \"\",\n  \"SecurityConfig\": \"\",\n  \"Content\": \"\",\n  \"ModelCardStatus\": \"\",\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: 105

{
  "ModelCardName": "",
  "SecurityConfig": "",
  "Content": "",
  "ModelCardStatus": "",
  "Tags": ""
}

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

client.close();

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

const data = JSON.stringify({
  ModelCardName: '',
  SecurityConfig: '',
  Content: '',
  ModelCardStatus: '',
  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=SageMaker.CreateModelCard');
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=SageMaker.CreateModelCard',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ModelCardName: '',
    SecurityConfig: '',
    Content: '',
    ModelCardStatus: '',
    Tags: ''
  }
};

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

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

const request = require('request');

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

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

req.type('json');
req.send({
  ModelCardName: '',
  SecurityConfig: '',
  Content: '',
  ModelCardStatus: '',
  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=SageMaker.CreateModelCard',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ModelCardName: '',
    SecurityConfig: '',
    Content: '',
    ModelCardStatus: '',
    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=SageMaker.CreateModelCard';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ModelCardName":"","SecurityConfig":"","Content":"","ModelCardStatus":"","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 = @{ @"ModelCardName": @"",
                              @"SecurityConfig": @"",
                              @"Content": @"",
                              @"ModelCardStatus": @"",
                              @"Tags": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelCard",
  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([
    'ModelCardName' => '',
    'SecurityConfig' => '',
    'Content' => '',
    'ModelCardStatus' => '',
    '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=SageMaker.CreateModelCard', [
  'body' => '{
  "ModelCardName": "",
  "SecurityConfig": "",
  "Content": "",
  "ModelCardStatus": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ModelCardName' => '',
  'SecurityConfig' => '',
  'Content' => '',
  'ModelCardStatus' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'ModelCardName' => '',
  'SecurityConfig' => '',
  'Content' => '',
  'ModelCardStatus' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelCard');
$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=SageMaker.CreateModelCard' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ModelCardName": "",
  "SecurityConfig": "",
  "Content": "",
  "ModelCardStatus": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelCard' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ModelCardName": "",
  "SecurityConfig": "",
  "Content": "",
  "ModelCardStatus": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"ModelCardName\": \"\",\n  \"SecurityConfig\": \"\",\n  \"Content\": \"\",\n  \"ModelCardStatus\": \"\",\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=SageMaker.CreateModelCard"

payload = {
    "ModelCardName": "",
    "SecurityConfig": "",
    "Content": "",
    "ModelCardStatus": "",
    "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=SageMaker.CreateModelCard"

payload <- "{\n  \"ModelCardName\": \"\",\n  \"SecurityConfig\": \"\",\n  \"Content\": \"\",\n  \"ModelCardStatus\": \"\",\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=SageMaker.CreateModelCard")

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  \"ModelCardName\": \"\",\n  \"SecurityConfig\": \"\",\n  \"Content\": \"\",\n  \"ModelCardStatus\": \"\",\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  \"ModelCardName\": \"\",\n  \"SecurityConfig\": \"\",\n  \"Content\": \"\",\n  \"ModelCardStatus\": \"\",\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=SageMaker.CreateModelCard";

    let payload = json!({
        "ModelCardName": "",
        "SecurityConfig": "",
        "Content": "",
        "ModelCardStatus": "",
        "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);
}

echo '{
  "ModelCardName": "",
  "SecurityConfig": "",
  "Content": "",
  "ModelCardStatus": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelCard' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ModelCardName": "",\n  "SecurityConfig": "",\n  "Content": "",\n  "ModelCardStatus": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelCard'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ModelCardName": "",
  "SecurityConfig": "",
  "Content": "",
  "ModelCardStatus": "",
  "Tags": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

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

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  \"ModelCardName\": \"\",\n  \"ModelCardVersion\": \"\",\n  \"ModelCardExportJobName\": \"\",\n  \"OutputConfig\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelCardExportJob" {:headers {:x-amz-target ""}
                                                                                             :content-type :json
                                                                                             :form-params {:ModelCardName ""
                                                                                                           :ModelCardVersion ""
                                                                                                           :ModelCardExportJobName ""
                                                                                                           :OutputConfig ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelCardExportJob"

	payload := strings.NewReader("{\n  \"ModelCardName\": \"\",\n  \"ModelCardVersion\": \"\",\n  \"ModelCardExportJobName\": \"\",\n  \"OutputConfig\": \"\"\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: 105

{
  "ModelCardName": "",
  "ModelCardVersion": "",
  "ModelCardExportJobName": "",
  "OutputConfig": ""
}

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

client.close();

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

const data = JSON.stringify({
  ModelCardName: '',
  ModelCardVersion: '',
  ModelCardExportJobName: '',
  OutputConfig: ''
});

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=SageMaker.CreateModelCardExportJob');
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=SageMaker.CreateModelCardExportJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ModelCardName: '',
    ModelCardVersion: '',
    ModelCardExportJobName: '',
    OutputConfig: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelCardExportJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ModelCardName":"","ModelCardVersion":"","ModelCardExportJobName":"","OutputConfig":""}'
};

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=SageMaker.CreateModelCardExportJob',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ModelCardName": "",\n  "ModelCardVersion": "",\n  "ModelCardExportJobName": "",\n  "OutputConfig": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  ModelCardName: '',
  ModelCardVersion: '',
  ModelCardExportJobName: '',
  OutputConfig: ''
});

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=SageMaker.CreateModelCardExportJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ModelCardName: '',
    ModelCardVersion: '',
    ModelCardExportJobName: '',
    OutputConfig: ''
  }
};

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=SageMaker.CreateModelCardExportJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ModelCardName":"","ModelCardVersion":"","ModelCardExportJobName":"","OutputConfig":""}'
};

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 = @{ @"ModelCardName": @"",
                              @"ModelCardVersion": @"",
                              @"ModelCardExportJobName": @"",
                              @"OutputConfig": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ModelCardName' => '',
  'ModelCardVersion' => '',
  'ModelCardExportJobName' => '',
  'OutputConfig' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"ModelCardName\": \"\",\n  \"ModelCardVersion\": \"\",\n  \"ModelCardExportJobName\": \"\",\n  \"OutputConfig\": \"\"\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=SageMaker.CreateModelCardExportJob"

payload = {
    "ModelCardName": "",
    "ModelCardVersion": "",
    "ModelCardExportJobName": "",
    "OutputConfig": ""
}
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=SageMaker.CreateModelCardExportJob"

payload <- "{\n  \"ModelCardName\": \"\",\n  \"ModelCardVersion\": \"\",\n  \"ModelCardExportJobName\": \"\",\n  \"OutputConfig\": \"\"\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=SageMaker.CreateModelCardExportJob")

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  \"ModelCardName\": \"\",\n  \"ModelCardVersion\": \"\",\n  \"ModelCardExportJobName\": \"\",\n  \"OutputConfig\": \"\"\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  \"ModelCardName\": \"\",\n  \"ModelCardVersion\": \"\",\n  \"ModelCardExportJobName\": \"\",\n  \"OutputConfig\": \"\"\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=SageMaker.CreateModelCardExportJob";

    let payload = json!({
        "ModelCardName": "",
        "ModelCardVersion": "",
        "ModelCardExportJobName": "",
        "OutputConfig": ""
    });

    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);
}

echo '{
  "ModelCardName": "",
  "ModelCardVersion": "",
  "ModelCardExportJobName": "",
  "OutputConfig": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelCardExportJob' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ModelCardName": "",\n  "ModelCardVersion": "",\n  "ModelCardExportJobName": "",\n  "OutputConfig": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelCardExportJob'

import Foundation

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

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

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

CURL *hnd = curl_easy_init();

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

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  \"JobDefinitionName\": \"\",\n  \"ModelExplainabilityBaselineConfig\": \"\",\n  \"ModelExplainabilityAppSpecification\": \"\",\n  \"ModelExplainabilityJobInput\": \"\",\n  \"ModelExplainabilityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelExplainabilityJobDefinition" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:JobDefinitionName ""
                                                                                                                         :ModelExplainabilityBaselineConfig ""
                                                                                                                         :ModelExplainabilityAppSpecification ""
                                                                                                                         :ModelExplainabilityJobInput ""
                                                                                                                         :ModelExplainabilityJobOutputConfig {:MonitoringOutputs ""
                                                                                                                                                              :KmsKeyId ""}
                                                                                                                         :JobResources {:ClusterConfig ""}
                                                                                                                         :NetworkConfig ""
                                                                                                                         :RoleArn ""
                                                                                                                         :StoppingCondition {:MaxRuntimeInSeconds ""}
                                                                                                                         :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelExplainabilityJobDefinition"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"JobDefinitionName\": \"\",\n  \"ModelExplainabilityBaselineConfig\": \"\",\n  \"ModelExplainabilityAppSpecification\": \"\",\n  \"ModelExplainabilityJobInput\": \"\",\n  \"ModelExplainabilityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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=SageMaker.CreateModelExplainabilityJobDefinition"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"JobDefinitionName\": \"\",\n  \"ModelExplainabilityBaselineConfig\": \"\",\n  \"ModelExplainabilityAppSpecification\": \"\",\n  \"ModelExplainabilityJobInput\": \"\",\n  \"ModelExplainabilityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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=SageMaker.CreateModelExplainabilityJobDefinition");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"JobDefinitionName\": \"\",\n  \"ModelExplainabilityBaselineConfig\": \"\",\n  \"ModelExplainabilityAppSpecification\": \"\",\n  \"ModelExplainabilityJobInput\": \"\",\n  \"ModelExplainabilityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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=SageMaker.CreateModelExplainabilityJobDefinition"

	payload := strings.NewReader("{\n  \"JobDefinitionName\": \"\",\n  \"ModelExplainabilityBaselineConfig\": \"\",\n  \"ModelExplainabilityAppSpecification\": \"\",\n  \"ModelExplainabilityJobInput\": \"\",\n  \"ModelExplainabilityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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: 412

{
  "JobDefinitionName": "",
  "ModelExplainabilityBaselineConfig": "",
  "ModelExplainabilityAppSpecification": "",
  "ModelExplainabilityJobInput": "",
  "ModelExplainabilityJobOutputConfig": {
    "MonitoringOutputs": "",
    "KmsKeyId": ""
  },
  "JobResources": {
    "ClusterConfig": ""
  },
  "NetworkConfig": "",
  "RoleArn": "",
  "StoppingCondition": {
    "MaxRuntimeInSeconds": ""
  },
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelExplainabilityJobDefinition")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"JobDefinitionName\": \"\",\n  \"ModelExplainabilityBaselineConfig\": \"\",\n  \"ModelExplainabilityAppSpecification\": \"\",\n  \"ModelExplainabilityJobInput\": \"\",\n  \"ModelExplainabilityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelExplainabilityJobDefinition"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"JobDefinitionName\": \"\",\n  \"ModelExplainabilityBaselineConfig\": \"\",\n  \"ModelExplainabilityAppSpecification\": \"\",\n  \"ModelExplainabilityJobInput\": \"\",\n  \"ModelExplainabilityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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  \"JobDefinitionName\": \"\",\n  \"ModelExplainabilityBaselineConfig\": \"\",\n  \"ModelExplainabilityAppSpecification\": \"\",\n  \"ModelExplainabilityJobInput\": \"\",\n  \"ModelExplainabilityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelExplainabilityJobDefinition")
  .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=SageMaker.CreateModelExplainabilityJobDefinition")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"JobDefinitionName\": \"\",\n  \"ModelExplainabilityBaselineConfig\": \"\",\n  \"ModelExplainabilityAppSpecification\": \"\",\n  \"ModelExplainabilityJobInput\": \"\",\n  \"ModelExplainabilityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  JobDefinitionName: '',
  ModelExplainabilityBaselineConfig: '',
  ModelExplainabilityAppSpecification: '',
  ModelExplainabilityJobInput: '',
  ModelExplainabilityJobOutputConfig: {
    MonitoringOutputs: '',
    KmsKeyId: ''
  },
  JobResources: {
    ClusterConfig: ''
  },
  NetworkConfig: '',
  RoleArn: '',
  StoppingCondition: {
    MaxRuntimeInSeconds: ''
  },
  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=SageMaker.CreateModelExplainabilityJobDefinition');
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=SageMaker.CreateModelExplainabilityJobDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    JobDefinitionName: '',
    ModelExplainabilityBaselineConfig: '',
    ModelExplainabilityAppSpecification: '',
    ModelExplainabilityJobInput: '',
    ModelExplainabilityJobOutputConfig: {MonitoringOutputs: '', KmsKeyId: ''},
    JobResources: {ClusterConfig: ''},
    NetworkConfig: '',
    RoleArn: '',
    StoppingCondition: {MaxRuntimeInSeconds: ''},
    Tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelExplainabilityJobDefinition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"JobDefinitionName":"","ModelExplainabilityBaselineConfig":"","ModelExplainabilityAppSpecification":"","ModelExplainabilityJobInput":"","ModelExplainabilityJobOutputConfig":{"MonitoringOutputs":"","KmsKeyId":""},"JobResources":{"ClusterConfig":""},"NetworkConfig":"","RoleArn":"","StoppingCondition":{"MaxRuntimeInSeconds":""},"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=SageMaker.CreateModelExplainabilityJobDefinition',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "JobDefinitionName": "",\n  "ModelExplainabilityBaselineConfig": "",\n  "ModelExplainabilityAppSpecification": "",\n  "ModelExplainabilityJobInput": "",\n  "ModelExplainabilityJobOutputConfig": {\n    "MonitoringOutputs": "",\n    "KmsKeyId": ""\n  },\n  "JobResources": {\n    "ClusterConfig": ""\n  },\n  "NetworkConfig": "",\n  "RoleArn": "",\n  "StoppingCondition": {\n    "MaxRuntimeInSeconds": ""\n  },\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  \"JobDefinitionName\": \"\",\n  \"ModelExplainabilityBaselineConfig\": \"\",\n  \"ModelExplainabilityAppSpecification\": \"\",\n  \"ModelExplainabilityJobInput\": \"\",\n  \"ModelExplainabilityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelExplainabilityJobDefinition")
  .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({
  JobDefinitionName: '',
  ModelExplainabilityBaselineConfig: '',
  ModelExplainabilityAppSpecification: '',
  ModelExplainabilityJobInput: '',
  ModelExplainabilityJobOutputConfig: {MonitoringOutputs: '', KmsKeyId: ''},
  JobResources: {ClusterConfig: ''},
  NetworkConfig: '',
  RoleArn: '',
  StoppingCondition: {MaxRuntimeInSeconds: ''},
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelExplainabilityJobDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    JobDefinitionName: '',
    ModelExplainabilityBaselineConfig: '',
    ModelExplainabilityAppSpecification: '',
    ModelExplainabilityJobInput: '',
    ModelExplainabilityJobOutputConfig: {MonitoringOutputs: '', KmsKeyId: ''},
    JobResources: {ClusterConfig: ''},
    NetworkConfig: '',
    RoleArn: '',
    StoppingCondition: {MaxRuntimeInSeconds: ''},
    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=SageMaker.CreateModelExplainabilityJobDefinition');

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

req.type('json');
req.send({
  JobDefinitionName: '',
  ModelExplainabilityBaselineConfig: '',
  ModelExplainabilityAppSpecification: '',
  ModelExplainabilityJobInput: '',
  ModelExplainabilityJobOutputConfig: {
    MonitoringOutputs: '',
    KmsKeyId: ''
  },
  JobResources: {
    ClusterConfig: ''
  },
  NetworkConfig: '',
  RoleArn: '',
  StoppingCondition: {
    MaxRuntimeInSeconds: ''
  },
  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=SageMaker.CreateModelExplainabilityJobDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    JobDefinitionName: '',
    ModelExplainabilityBaselineConfig: '',
    ModelExplainabilityAppSpecification: '',
    ModelExplainabilityJobInput: '',
    ModelExplainabilityJobOutputConfig: {MonitoringOutputs: '', KmsKeyId: ''},
    JobResources: {ClusterConfig: ''},
    NetworkConfig: '',
    RoleArn: '',
    StoppingCondition: {MaxRuntimeInSeconds: ''},
    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=SageMaker.CreateModelExplainabilityJobDefinition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"JobDefinitionName":"","ModelExplainabilityBaselineConfig":"","ModelExplainabilityAppSpecification":"","ModelExplainabilityJobInput":"","ModelExplainabilityJobOutputConfig":{"MonitoringOutputs":"","KmsKeyId":""},"JobResources":{"ClusterConfig":""},"NetworkConfig":"","RoleArn":"","StoppingCondition":{"MaxRuntimeInSeconds":""},"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 = @{ @"JobDefinitionName": @"",
                              @"ModelExplainabilityBaselineConfig": @"",
                              @"ModelExplainabilityAppSpecification": @"",
                              @"ModelExplainabilityJobInput": @"",
                              @"ModelExplainabilityJobOutputConfig": @{ @"MonitoringOutputs": @"", @"KmsKeyId": @"" },
                              @"JobResources": @{ @"ClusterConfig": @"" },
                              @"NetworkConfig": @"",
                              @"RoleArn": @"",
                              @"StoppingCondition": @{ @"MaxRuntimeInSeconds": @"" },
                              @"Tags": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelExplainabilityJobDefinition"]
                                                       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=SageMaker.CreateModelExplainabilityJobDefinition" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"JobDefinitionName\": \"\",\n  \"ModelExplainabilityBaselineConfig\": \"\",\n  \"ModelExplainabilityAppSpecification\": \"\",\n  \"ModelExplainabilityJobInput\": \"\",\n  \"ModelExplainabilityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\n  \"Tags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelExplainabilityJobDefinition",
  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([
    'JobDefinitionName' => '',
    'ModelExplainabilityBaselineConfig' => '',
    'ModelExplainabilityAppSpecification' => '',
    'ModelExplainabilityJobInput' => '',
    'ModelExplainabilityJobOutputConfig' => [
        'MonitoringOutputs' => '',
        'KmsKeyId' => ''
    ],
    'JobResources' => [
        'ClusterConfig' => ''
    ],
    'NetworkConfig' => '',
    'RoleArn' => '',
    'StoppingCondition' => [
        'MaxRuntimeInSeconds' => ''
    ],
    '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=SageMaker.CreateModelExplainabilityJobDefinition', [
  'body' => '{
  "JobDefinitionName": "",
  "ModelExplainabilityBaselineConfig": "",
  "ModelExplainabilityAppSpecification": "",
  "ModelExplainabilityJobInput": "",
  "ModelExplainabilityJobOutputConfig": {
    "MonitoringOutputs": "",
    "KmsKeyId": ""
  },
  "JobResources": {
    "ClusterConfig": ""
  },
  "NetworkConfig": "",
  "RoleArn": "",
  "StoppingCondition": {
    "MaxRuntimeInSeconds": ""
  },
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'JobDefinitionName' => '',
  'ModelExplainabilityBaselineConfig' => '',
  'ModelExplainabilityAppSpecification' => '',
  'ModelExplainabilityJobInput' => '',
  'ModelExplainabilityJobOutputConfig' => [
    'MonitoringOutputs' => '',
    'KmsKeyId' => ''
  ],
  'JobResources' => [
    'ClusterConfig' => ''
  ],
  'NetworkConfig' => '',
  'RoleArn' => '',
  'StoppingCondition' => [
    'MaxRuntimeInSeconds' => ''
  ],
  'Tags' => ''
]));

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

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

append(json_encode([
  'JobDefinitionName' => '',
  'ModelExplainabilityBaselineConfig' => '',
  'ModelExplainabilityAppSpecification' => '',
  'ModelExplainabilityJobInput' => '',
  'ModelExplainabilityJobOutputConfig' => [
    'MonitoringOutputs' => '',
    'KmsKeyId' => ''
  ],
  'JobResources' => [
    'ClusterConfig' => ''
  ],
  'NetworkConfig' => '',
  'RoleArn' => '',
  'StoppingCondition' => [
    'MaxRuntimeInSeconds' => ''
  ],
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelExplainabilityJobDefinition');
$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=SageMaker.CreateModelExplainabilityJobDefinition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "JobDefinitionName": "",
  "ModelExplainabilityBaselineConfig": "",
  "ModelExplainabilityAppSpecification": "",
  "ModelExplainabilityJobInput": "",
  "ModelExplainabilityJobOutputConfig": {
    "MonitoringOutputs": "",
    "KmsKeyId": ""
  },
  "JobResources": {
    "ClusterConfig": ""
  },
  "NetworkConfig": "",
  "RoleArn": "",
  "StoppingCondition": {
    "MaxRuntimeInSeconds": ""
  },
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelExplainabilityJobDefinition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "JobDefinitionName": "",
  "ModelExplainabilityBaselineConfig": "",
  "ModelExplainabilityAppSpecification": "",
  "ModelExplainabilityJobInput": "",
  "ModelExplainabilityJobOutputConfig": {
    "MonitoringOutputs": "",
    "KmsKeyId": ""
  },
  "JobResources": {
    "ClusterConfig": ""
  },
  "NetworkConfig": "",
  "RoleArn": "",
  "StoppingCondition": {
    "MaxRuntimeInSeconds": ""
  },
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"JobDefinitionName\": \"\",\n  \"ModelExplainabilityBaselineConfig\": \"\",\n  \"ModelExplainabilityAppSpecification\": \"\",\n  \"ModelExplainabilityJobInput\": \"\",\n  \"ModelExplainabilityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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=SageMaker.CreateModelExplainabilityJobDefinition"

payload = {
    "JobDefinitionName": "",
    "ModelExplainabilityBaselineConfig": "",
    "ModelExplainabilityAppSpecification": "",
    "ModelExplainabilityJobInput": "",
    "ModelExplainabilityJobOutputConfig": {
        "MonitoringOutputs": "",
        "KmsKeyId": ""
    },
    "JobResources": { "ClusterConfig": "" },
    "NetworkConfig": "",
    "RoleArn": "",
    "StoppingCondition": { "MaxRuntimeInSeconds": "" },
    "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=SageMaker.CreateModelExplainabilityJobDefinition"

payload <- "{\n  \"JobDefinitionName\": \"\",\n  \"ModelExplainabilityBaselineConfig\": \"\",\n  \"ModelExplainabilityAppSpecification\": \"\",\n  \"ModelExplainabilityJobInput\": \"\",\n  \"ModelExplainabilityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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=SageMaker.CreateModelExplainabilityJobDefinition")

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  \"JobDefinitionName\": \"\",\n  \"ModelExplainabilityBaselineConfig\": \"\",\n  \"ModelExplainabilityAppSpecification\": \"\",\n  \"ModelExplainabilityJobInput\": \"\",\n  \"ModelExplainabilityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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  \"JobDefinitionName\": \"\",\n  \"ModelExplainabilityBaselineConfig\": \"\",\n  \"ModelExplainabilityAppSpecification\": \"\",\n  \"ModelExplainabilityJobInput\": \"\",\n  \"ModelExplainabilityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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=SageMaker.CreateModelExplainabilityJobDefinition";

    let payload = json!({
        "JobDefinitionName": "",
        "ModelExplainabilityBaselineConfig": "",
        "ModelExplainabilityAppSpecification": "",
        "ModelExplainabilityJobInput": "",
        "ModelExplainabilityJobOutputConfig": json!({
            "MonitoringOutputs": "",
            "KmsKeyId": ""
        }),
        "JobResources": json!({"ClusterConfig": ""}),
        "NetworkConfig": "",
        "RoleArn": "",
        "StoppingCondition": json!({"MaxRuntimeInSeconds": ""}),
        "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);
}

echo '{
  "JobDefinitionName": "",
  "ModelExplainabilityBaselineConfig": "",
  "ModelExplainabilityAppSpecification": "",
  "ModelExplainabilityJobInput": "",
  "ModelExplainabilityJobOutputConfig": {
    "MonitoringOutputs": "",
    "KmsKeyId": ""
  },
  "JobResources": {
    "ClusterConfig": ""
  },
  "NetworkConfig": "",
  "RoleArn": "",
  "StoppingCondition": {
    "MaxRuntimeInSeconds": ""
  },
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelExplainabilityJobDefinition' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "JobDefinitionName": "",\n  "ModelExplainabilityBaselineConfig": "",\n  "ModelExplainabilityAppSpecification": "",\n  "ModelExplainabilityJobInput": "",\n  "ModelExplainabilityJobOutputConfig": {\n    "MonitoringOutputs": "",\n    "KmsKeyId": ""\n  },\n  "JobResources": {\n    "ClusterConfig": ""\n  },\n  "NetworkConfig": "",\n  "RoleArn": "",\n  "StoppingCondition": {\n    "MaxRuntimeInSeconds": ""\n  },\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelExplainabilityJobDefinition'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "JobDefinitionName": "",
  "ModelExplainabilityBaselineConfig": "",
  "ModelExplainabilityAppSpecification": "",
  "ModelExplainabilityJobInput": "",
  "ModelExplainabilityJobOutputConfig": [
    "MonitoringOutputs": "",
    "KmsKeyId": ""
  ],
  "JobResources": ["ClusterConfig": ""],
  "NetworkConfig": "",
  "RoleArn": "",
  "StoppingCondition": ["MaxRuntimeInSeconds": ""],
  "Tags": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

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

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  \"ModelPackageName\": \"\",\n  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageDescription\": \"\",\n  \"InferenceSpecification\": \"\",\n  \"ValidationSpecification\": \"\",\n  \"SourceAlgorithmSpecification\": \"\",\n  \"CertifyForMarketplace\": \"\",\n  \"Tags\": \"\",\n  \"ModelApprovalStatus\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\n  \"ModelMetrics\": \"\",\n  \"ClientToken\": \"\",\n  \"CustomerMetadataProperties\": \"\",\n  \"DriftCheckBaselines\": \"\",\n  \"Domain\": \"\",\n  \"Task\": \"\",\n  \"SamplePayloadUrl\": \"\",\n  \"AdditionalInferenceSpecifications\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackage" {:headers {:x-amz-target ""}
                                                                                       :content-type :json
                                                                                       :form-params {:ModelPackageName ""
                                                                                                     :ModelPackageGroupName ""
                                                                                                     :ModelPackageDescription ""
                                                                                                     :InferenceSpecification ""
                                                                                                     :ValidationSpecification ""
                                                                                                     :SourceAlgorithmSpecification ""
                                                                                                     :CertifyForMarketplace ""
                                                                                                     :Tags ""
                                                                                                     :ModelApprovalStatus ""
                                                                                                     :MetadataProperties {:CommitId ""
                                                                                                                          :Repository ""
                                                                                                                          :GeneratedBy ""
                                                                                                                          :ProjectId ""}
                                                                                                     :ModelMetrics ""
                                                                                                     :ClientToken ""
                                                                                                     :CustomerMetadataProperties ""
                                                                                                     :DriftCheckBaselines ""
                                                                                                     :Domain ""
                                                                                                     :Task ""
                                                                                                     :SamplePayloadUrl ""
                                                                                                     :AdditionalInferenceSpecifications ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackage"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ModelPackageName\": \"\",\n  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageDescription\": \"\",\n  \"InferenceSpecification\": \"\",\n  \"ValidationSpecification\": \"\",\n  \"SourceAlgorithmSpecification\": \"\",\n  \"CertifyForMarketplace\": \"\",\n  \"Tags\": \"\",\n  \"ModelApprovalStatus\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\n  \"ModelMetrics\": \"\",\n  \"ClientToken\": \"\",\n  \"CustomerMetadataProperties\": \"\",\n  \"DriftCheckBaselines\": \"\",\n  \"Domain\": \"\",\n  \"Task\": \"\",\n  \"SamplePayloadUrl\": \"\",\n  \"AdditionalInferenceSpecifications\": \"\"\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=SageMaker.CreateModelPackage"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ModelPackageName\": \"\",\n  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageDescription\": \"\",\n  \"InferenceSpecification\": \"\",\n  \"ValidationSpecification\": \"\",\n  \"SourceAlgorithmSpecification\": \"\",\n  \"CertifyForMarketplace\": \"\",\n  \"Tags\": \"\",\n  \"ModelApprovalStatus\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\n  \"ModelMetrics\": \"\",\n  \"ClientToken\": \"\",\n  \"CustomerMetadataProperties\": \"\",\n  \"DriftCheckBaselines\": \"\",\n  \"Domain\": \"\",\n  \"Task\": \"\",\n  \"SamplePayloadUrl\": \"\",\n  \"AdditionalInferenceSpecifications\": \"\"\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=SageMaker.CreateModelPackage");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ModelPackageName\": \"\",\n  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageDescription\": \"\",\n  \"InferenceSpecification\": \"\",\n  \"ValidationSpecification\": \"\",\n  \"SourceAlgorithmSpecification\": \"\",\n  \"CertifyForMarketplace\": \"\",\n  \"Tags\": \"\",\n  \"ModelApprovalStatus\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\n  \"ModelMetrics\": \"\",\n  \"ClientToken\": \"\",\n  \"CustomerMetadataProperties\": \"\",\n  \"DriftCheckBaselines\": \"\",\n  \"Domain\": \"\",\n  \"Task\": \"\",\n  \"SamplePayloadUrl\": \"\",\n  \"AdditionalInferenceSpecifications\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackage"

	payload := strings.NewReader("{\n  \"ModelPackageName\": \"\",\n  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageDescription\": \"\",\n  \"InferenceSpecification\": \"\",\n  \"ValidationSpecification\": \"\",\n  \"SourceAlgorithmSpecification\": \"\",\n  \"CertifyForMarketplace\": \"\",\n  \"Tags\": \"\",\n  \"ModelApprovalStatus\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\n  \"ModelMetrics\": \"\",\n  \"ClientToken\": \"\",\n  \"CustomerMetadataProperties\": \"\",\n  \"DriftCheckBaselines\": \"\",\n  \"Domain\": \"\",\n  \"Task\": \"\",\n  \"SamplePayloadUrl\": \"\",\n  \"AdditionalInferenceSpecifications\": \"\"\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: 592

{
  "ModelPackageName": "",
  "ModelPackageGroupName": "",
  "ModelPackageDescription": "",
  "InferenceSpecification": "",
  "ValidationSpecification": "",
  "SourceAlgorithmSpecification": "",
  "CertifyForMarketplace": "",
  "Tags": "",
  "ModelApprovalStatus": "",
  "MetadataProperties": {
    "CommitId": "",
    "Repository": "",
    "GeneratedBy": "",
    "ProjectId": ""
  },
  "ModelMetrics": "",
  "ClientToken": "",
  "CustomerMetadataProperties": "",
  "DriftCheckBaselines": "",
  "Domain": "",
  "Task": "",
  "SamplePayloadUrl": "",
  "AdditionalInferenceSpecifications": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackage")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ModelPackageName\": \"\",\n  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageDescription\": \"\",\n  \"InferenceSpecification\": \"\",\n  \"ValidationSpecification\": \"\",\n  \"SourceAlgorithmSpecification\": \"\",\n  \"CertifyForMarketplace\": \"\",\n  \"Tags\": \"\",\n  \"ModelApprovalStatus\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\n  \"ModelMetrics\": \"\",\n  \"ClientToken\": \"\",\n  \"CustomerMetadataProperties\": \"\",\n  \"DriftCheckBaselines\": \"\",\n  \"Domain\": \"\",\n  \"Task\": \"\",\n  \"SamplePayloadUrl\": \"\",\n  \"AdditionalInferenceSpecifications\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackage"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ModelPackageName\": \"\",\n  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageDescription\": \"\",\n  \"InferenceSpecification\": \"\",\n  \"ValidationSpecification\": \"\",\n  \"SourceAlgorithmSpecification\": \"\",\n  \"CertifyForMarketplace\": \"\",\n  \"Tags\": \"\",\n  \"ModelApprovalStatus\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\n  \"ModelMetrics\": \"\",\n  \"ClientToken\": \"\",\n  \"CustomerMetadataProperties\": \"\",\n  \"DriftCheckBaselines\": \"\",\n  \"Domain\": \"\",\n  \"Task\": \"\",\n  \"SamplePayloadUrl\": \"\",\n  \"AdditionalInferenceSpecifications\": \"\"\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  \"ModelPackageName\": \"\",\n  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageDescription\": \"\",\n  \"InferenceSpecification\": \"\",\n  \"ValidationSpecification\": \"\",\n  \"SourceAlgorithmSpecification\": \"\",\n  \"CertifyForMarketplace\": \"\",\n  \"Tags\": \"\",\n  \"ModelApprovalStatus\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\n  \"ModelMetrics\": \"\",\n  \"ClientToken\": \"\",\n  \"CustomerMetadataProperties\": \"\",\n  \"DriftCheckBaselines\": \"\",\n  \"Domain\": \"\",\n  \"Task\": \"\",\n  \"SamplePayloadUrl\": \"\",\n  \"AdditionalInferenceSpecifications\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackage")
  .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=SageMaker.CreateModelPackage")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ModelPackageName\": \"\",\n  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageDescription\": \"\",\n  \"InferenceSpecification\": \"\",\n  \"ValidationSpecification\": \"\",\n  \"SourceAlgorithmSpecification\": \"\",\n  \"CertifyForMarketplace\": \"\",\n  \"Tags\": \"\",\n  \"ModelApprovalStatus\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\n  \"ModelMetrics\": \"\",\n  \"ClientToken\": \"\",\n  \"CustomerMetadataProperties\": \"\",\n  \"DriftCheckBaselines\": \"\",\n  \"Domain\": \"\",\n  \"Task\": \"\",\n  \"SamplePayloadUrl\": \"\",\n  \"AdditionalInferenceSpecifications\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ModelPackageName: '',
  ModelPackageGroupName: '',
  ModelPackageDescription: '',
  InferenceSpecification: '',
  ValidationSpecification: '',
  SourceAlgorithmSpecification: '',
  CertifyForMarketplace: '',
  Tags: '',
  ModelApprovalStatus: '',
  MetadataProperties: {
    CommitId: '',
    Repository: '',
    GeneratedBy: '',
    ProjectId: ''
  },
  ModelMetrics: '',
  ClientToken: '',
  CustomerMetadataProperties: '',
  DriftCheckBaselines: '',
  Domain: '',
  Task: '',
  SamplePayloadUrl: '',
  AdditionalInferenceSpecifications: ''
});

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=SageMaker.CreateModelPackage');
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=SageMaker.CreateModelPackage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ModelPackageName: '',
    ModelPackageGroupName: '',
    ModelPackageDescription: '',
    InferenceSpecification: '',
    ValidationSpecification: '',
    SourceAlgorithmSpecification: '',
    CertifyForMarketplace: '',
    Tags: '',
    ModelApprovalStatus: '',
    MetadataProperties: {CommitId: '', Repository: '', GeneratedBy: '', ProjectId: ''},
    ModelMetrics: '',
    ClientToken: '',
    CustomerMetadataProperties: '',
    DriftCheckBaselines: '',
    Domain: '',
    Task: '',
    SamplePayloadUrl: '',
    AdditionalInferenceSpecifications: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackage';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ModelPackageName":"","ModelPackageGroupName":"","ModelPackageDescription":"","InferenceSpecification":"","ValidationSpecification":"","SourceAlgorithmSpecification":"","CertifyForMarketplace":"","Tags":"","ModelApprovalStatus":"","MetadataProperties":{"CommitId":"","Repository":"","GeneratedBy":"","ProjectId":""},"ModelMetrics":"","ClientToken":"","CustomerMetadataProperties":"","DriftCheckBaselines":"","Domain":"","Task":"","SamplePayloadUrl":"","AdditionalInferenceSpecifications":""}'
};

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=SageMaker.CreateModelPackage',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ModelPackageName": "",\n  "ModelPackageGroupName": "",\n  "ModelPackageDescription": "",\n  "InferenceSpecification": "",\n  "ValidationSpecification": "",\n  "SourceAlgorithmSpecification": "",\n  "CertifyForMarketplace": "",\n  "Tags": "",\n  "ModelApprovalStatus": "",\n  "MetadataProperties": {\n    "CommitId": "",\n    "Repository": "",\n    "GeneratedBy": "",\n    "ProjectId": ""\n  },\n  "ModelMetrics": "",\n  "ClientToken": "",\n  "CustomerMetadataProperties": "",\n  "DriftCheckBaselines": "",\n  "Domain": "",\n  "Task": "",\n  "SamplePayloadUrl": "",\n  "AdditionalInferenceSpecifications": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ModelPackageName\": \"\",\n  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageDescription\": \"\",\n  \"InferenceSpecification\": \"\",\n  \"ValidationSpecification\": \"\",\n  \"SourceAlgorithmSpecification\": \"\",\n  \"CertifyForMarketplace\": \"\",\n  \"Tags\": \"\",\n  \"ModelApprovalStatus\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\n  \"ModelMetrics\": \"\",\n  \"ClientToken\": \"\",\n  \"CustomerMetadataProperties\": \"\",\n  \"DriftCheckBaselines\": \"\",\n  \"Domain\": \"\",\n  \"Task\": \"\",\n  \"SamplePayloadUrl\": \"\",\n  \"AdditionalInferenceSpecifications\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackage")
  .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({
  ModelPackageName: '',
  ModelPackageGroupName: '',
  ModelPackageDescription: '',
  InferenceSpecification: '',
  ValidationSpecification: '',
  SourceAlgorithmSpecification: '',
  CertifyForMarketplace: '',
  Tags: '',
  ModelApprovalStatus: '',
  MetadataProperties: {CommitId: '', Repository: '', GeneratedBy: '', ProjectId: ''},
  ModelMetrics: '',
  ClientToken: '',
  CustomerMetadataProperties: '',
  DriftCheckBaselines: '',
  Domain: '',
  Task: '',
  SamplePayloadUrl: '',
  AdditionalInferenceSpecifications: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ModelPackageName: '',
    ModelPackageGroupName: '',
    ModelPackageDescription: '',
    InferenceSpecification: '',
    ValidationSpecification: '',
    SourceAlgorithmSpecification: '',
    CertifyForMarketplace: '',
    Tags: '',
    ModelApprovalStatus: '',
    MetadataProperties: {CommitId: '', Repository: '', GeneratedBy: '', ProjectId: ''},
    ModelMetrics: '',
    ClientToken: '',
    CustomerMetadataProperties: '',
    DriftCheckBaselines: '',
    Domain: '',
    Task: '',
    SamplePayloadUrl: '',
    AdditionalInferenceSpecifications: ''
  },
  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=SageMaker.CreateModelPackage');

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

req.type('json');
req.send({
  ModelPackageName: '',
  ModelPackageGroupName: '',
  ModelPackageDescription: '',
  InferenceSpecification: '',
  ValidationSpecification: '',
  SourceAlgorithmSpecification: '',
  CertifyForMarketplace: '',
  Tags: '',
  ModelApprovalStatus: '',
  MetadataProperties: {
    CommitId: '',
    Repository: '',
    GeneratedBy: '',
    ProjectId: ''
  },
  ModelMetrics: '',
  ClientToken: '',
  CustomerMetadataProperties: '',
  DriftCheckBaselines: '',
  Domain: '',
  Task: '',
  SamplePayloadUrl: '',
  AdditionalInferenceSpecifications: ''
});

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=SageMaker.CreateModelPackage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ModelPackageName: '',
    ModelPackageGroupName: '',
    ModelPackageDescription: '',
    InferenceSpecification: '',
    ValidationSpecification: '',
    SourceAlgorithmSpecification: '',
    CertifyForMarketplace: '',
    Tags: '',
    ModelApprovalStatus: '',
    MetadataProperties: {CommitId: '', Repository: '', GeneratedBy: '', ProjectId: ''},
    ModelMetrics: '',
    ClientToken: '',
    CustomerMetadataProperties: '',
    DriftCheckBaselines: '',
    Domain: '',
    Task: '',
    SamplePayloadUrl: '',
    AdditionalInferenceSpecifications: ''
  }
};

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=SageMaker.CreateModelPackage';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ModelPackageName":"","ModelPackageGroupName":"","ModelPackageDescription":"","InferenceSpecification":"","ValidationSpecification":"","SourceAlgorithmSpecification":"","CertifyForMarketplace":"","Tags":"","ModelApprovalStatus":"","MetadataProperties":{"CommitId":"","Repository":"","GeneratedBy":"","ProjectId":""},"ModelMetrics":"","ClientToken":"","CustomerMetadataProperties":"","DriftCheckBaselines":"","Domain":"","Task":"","SamplePayloadUrl":"","AdditionalInferenceSpecifications":""}'
};

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 = @{ @"ModelPackageName": @"",
                              @"ModelPackageGroupName": @"",
                              @"ModelPackageDescription": @"",
                              @"InferenceSpecification": @"",
                              @"ValidationSpecification": @"",
                              @"SourceAlgorithmSpecification": @"",
                              @"CertifyForMarketplace": @"",
                              @"Tags": @"",
                              @"ModelApprovalStatus": @"",
                              @"MetadataProperties": @{ @"CommitId": @"", @"Repository": @"", @"GeneratedBy": @"", @"ProjectId": @"" },
                              @"ModelMetrics": @"",
                              @"ClientToken": @"",
                              @"CustomerMetadataProperties": @"",
                              @"DriftCheckBaselines": @"",
                              @"Domain": @"",
                              @"Task": @"",
                              @"SamplePayloadUrl": @"",
                              @"AdditionalInferenceSpecifications": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackage"]
                                                       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=SageMaker.CreateModelPackage" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ModelPackageName\": \"\",\n  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageDescription\": \"\",\n  \"InferenceSpecification\": \"\",\n  \"ValidationSpecification\": \"\",\n  \"SourceAlgorithmSpecification\": \"\",\n  \"CertifyForMarketplace\": \"\",\n  \"Tags\": \"\",\n  \"ModelApprovalStatus\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\n  \"ModelMetrics\": \"\",\n  \"ClientToken\": \"\",\n  \"CustomerMetadataProperties\": \"\",\n  \"DriftCheckBaselines\": \"\",\n  \"Domain\": \"\",\n  \"Task\": \"\",\n  \"SamplePayloadUrl\": \"\",\n  \"AdditionalInferenceSpecifications\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackage",
  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([
    'ModelPackageName' => '',
    'ModelPackageGroupName' => '',
    'ModelPackageDescription' => '',
    'InferenceSpecification' => '',
    'ValidationSpecification' => '',
    'SourceAlgorithmSpecification' => '',
    'CertifyForMarketplace' => '',
    'Tags' => '',
    'ModelApprovalStatus' => '',
    'MetadataProperties' => [
        'CommitId' => '',
        'Repository' => '',
        'GeneratedBy' => '',
        'ProjectId' => ''
    ],
    'ModelMetrics' => '',
    'ClientToken' => '',
    'CustomerMetadataProperties' => '',
    'DriftCheckBaselines' => '',
    'Domain' => '',
    'Task' => '',
    'SamplePayloadUrl' => '',
    'AdditionalInferenceSpecifications' => ''
  ]),
  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=SageMaker.CreateModelPackage', [
  'body' => '{
  "ModelPackageName": "",
  "ModelPackageGroupName": "",
  "ModelPackageDescription": "",
  "InferenceSpecification": "",
  "ValidationSpecification": "",
  "SourceAlgorithmSpecification": "",
  "CertifyForMarketplace": "",
  "Tags": "",
  "ModelApprovalStatus": "",
  "MetadataProperties": {
    "CommitId": "",
    "Repository": "",
    "GeneratedBy": "",
    "ProjectId": ""
  },
  "ModelMetrics": "",
  "ClientToken": "",
  "CustomerMetadataProperties": "",
  "DriftCheckBaselines": "",
  "Domain": "",
  "Task": "",
  "SamplePayloadUrl": "",
  "AdditionalInferenceSpecifications": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackage');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ModelPackageName' => '',
  'ModelPackageGroupName' => '',
  'ModelPackageDescription' => '',
  'InferenceSpecification' => '',
  'ValidationSpecification' => '',
  'SourceAlgorithmSpecification' => '',
  'CertifyForMarketplace' => '',
  'Tags' => '',
  'ModelApprovalStatus' => '',
  'MetadataProperties' => [
    'CommitId' => '',
    'Repository' => '',
    'GeneratedBy' => '',
    'ProjectId' => ''
  ],
  'ModelMetrics' => '',
  'ClientToken' => '',
  'CustomerMetadataProperties' => '',
  'DriftCheckBaselines' => '',
  'Domain' => '',
  'Task' => '',
  'SamplePayloadUrl' => '',
  'AdditionalInferenceSpecifications' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ModelPackageName' => '',
  'ModelPackageGroupName' => '',
  'ModelPackageDescription' => '',
  'InferenceSpecification' => '',
  'ValidationSpecification' => '',
  'SourceAlgorithmSpecification' => '',
  'CertifyForMarketplace' => '',
  'Tags' => '',
  'ModelApprovalStatus' => '',
  'MetadataProperties' => [
    'CommitId' => '',
    'Repository' => '',
    'GeneratedBy' => '',
    'ProjectId' => ''
  ],
  'ModelMetrics' => '',
  'ClientToken' => '',
  'CustomerMetadataProperties' => '',
  'DriftCheckBaselines' => '',
  'Domain' => '',
  'Task' => '',
  'SamplePayloadUrl' => '',
  'AdditionalInferenceSpecifications' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackage');
$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=SageMaker.CreateModelPackage' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ModelPackageName": "",
  "ModelPackageGroupName": "",
  "ModelPackageDescription": "",
  "InferenceSpecification": "",
  "ValidationSpecification": "",
  "SourceAlgorithmSpecification": "",
  "CertifyForMarketplace": "",
  "Tags": "",
  "ModelApprovalStatus": "",
  "MetadataProperties": {
    "CommitId": "",
    "Repository": "",
    "GeneratedBy": "",
    "ProjectId": ""
  },
  "ModelMetrics": "",
  "ClientToken": "",
  "CustomerMetadataProperties": "",
  "DriftCheckBaselines": "",
  "Domain": "",
  "Task": "",
  "SamplePayloadUrl": "",
  "AdditionalInferenceSpecifications": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackage' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ModelPackageName": "",
  "ModelPackageGroupName": "",
  "ModelPackageDescription": "",
  "InferenceSpecification": "",
  "ValidationSpecification": "",
  "SourceAlgorithmSpecification": "",
  "CertifyForMarketplace": "",
  "Tags": "",
  "ModelApprovalStatus": "",
  "MetadataProperties": {
    "CommitId": "",
    "Repository": "",
    "GeneratedBy": "",
    "ProjectId": ""
  },
  "ModelMetrics": "",
  "ClientToken": "",
  "CustomerMetadataProperties": "",
  "DriftCheckBaselines": "",
  "Domain": "",
  "Task": "",
  "SamplePayloadUrl": "",
  "AdditionalInferenceSpecifications": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ModelPackageName\": \"\",\n  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageDescription\": \"\",\n  \"InferenceSpecification\": \"\",\n  \"ValidationSpecification\": \"\",\n  \"SourceAlgorithmSpecification\": \"\",\n  \"CertifyForMarketplace\": \"\",\n  \"Tags\": \"\",\n  \"ModelApprovalStatus\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\n  \"ModelMetrics\": \"\",\n  \"ClientToken\": \"\",\n  \"CustomerMetadataProperties\": \"\",\n  \"DriftCheckBaselines\": \"\",\n  \"Domain\": \"\",\n  \"Task\": \"\",\n  \"SamplePayloadUrl\": \"\",\n  \"AdditionalInferenceSpecifications\": \"\"\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=SageMaker.CreateModelPackage"

payload = {
    "ModelPackageName": "",
    "ModelPackageGroupName": "",
    "ModelPackageDescription": "",
    "InferenceSpecification": "",
    "ValidationSpecification": "",
    "SourceAlgorithmSpecification": "",
    "CertifyForMarketplace": "",
    "Tags": "",
    "ModelApprovalStatus": "",
    "MetadataProperties": {
        "CommitId": "",
        "Repository": "",
        "GeneratedBy": "",
        "ProjectId": ""
    },
    "ModelMetrics": "",
    "ClientToken": "",
    "CustomerMetadataProperties": "",
    "DriftCheckBaselines": "",
    "Domain": "",
    "Task": "",
    "SamplePayloadUrl": "",
    "AdditionalInferenceSpecifications": ""
}
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=SageMaker.CreateModelPackage"

payload <- "{\n  \"ModelPackageName\": \"\",\n  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageDescription\": \"\",\n  \"InferenceSpecification\": \"\",\n  \"ValidationSpecification\": \"\",\n  \"SourceAlgorithmSpecification\": \"\",\n  \"CertifyForMarketplace\": \"\",\n  \"Tags\": \"\",\n  \"ModelApprovalStatus\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\n  \"ModelMetrics\": \"\",\n  \"ClientToken\": \"\",\n  \"CustomerMetadataProperties\": \"\",\n  \"DriftCheckBaselines\": \"\",\n  \"Domain\": \"\",\n  \"Task\": \"\",\n  \"SamplePayloadUrl\": \"\",\n  \"AdditionalInferenceSpecifications\": \"\"\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=SageMaker.CreateModelPackage")

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  \"ModelPackageName\": \"\",\n  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageDescription\": \"\",\n  \"InferenceSpecification\": \"\",\n  \"ValidationSpecification\": \"\",\n  \"SourceAlgorithmSpecification\": \"\",\n  \"CertifyForMarketplace\": \"\",\n  \"Tags\": \"\",\n  \"ModelApprovalStatus\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\n  \"ModelMetrics\": \"\",\n  \"ClientToken\": \"\",\n  \"CustomerMetadataProperties\": \"\",\n  \"DriftCheckBaselines\": \"\",\n  \"Domain\": \"\",\n  \"Task\": \"\",\n  \"SamplePayloadUrl\": \"\",\n  \"AdditionalInferenceSpecifications\": \"\"\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  \"ModelPackageName\": \"\",\n  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageDescription\": \"\",\n  \"InferenceSpecification\": \"\",\n  \"ValidationSpecification\": \"\",\n  \"SourceAlgorithmSpecification\": \"\",\n  \"CertifyForMarketplace\": \"\",\n  \"Tags\": \"\",\n  \"ModelApprovalStatus\": \"\",\n  \"MetadataProperties\": {\n    \"CommitId\": \"\",\n    \"Repository\": \"\",\n    \"GeneratedBy\": \"\",\n    \"ProjectId\": \"\"\n  },\n  \"ModelMetrics\": \"\",\n  \"ClientToken\": \"\",\n  \"CustomerMetadataProperties\": \"\",\n  \"DriftCheckBaselines\": \"\",\n  \"Domain\": \"\",\n  \"Task\": \"\",\n  \"SamplePayloadUrl\": \"\",\n  \"AdditionalInferenceSpecifications\": \"\"\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=SageMaker.CreateModelPackage";

    let payload = json!({
        "ModelPackageName": "",
        "ModelPackageGroupName": "",
        "ModelPackageDescription": "",
        "InferenceSpecification": "",
        "ValidationSpecification": "",
        "SourceAlgorithmSpecification": "",
        "CertifyForMarketplace": "",
        "Tags": "",
        "ModelApprovalStatus": "",
        "MetadataProperties": json!({
            "CommitId": "",
            "Repository": "",
            "GeneratedBy": "",
            "ProjectId": ""
        }),
        "ModelMetrics": "",
        "ClientToken": "",
        "CustomerMetadataProperties": "",
        "DriftCheckBaselines": "",
        "Domain": "",
        "Task": "",
        "SamplePayloadUrl": "",
        "AdditionalInferenceSpecifications": ""
    });

    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);
}

echo '{
  "ModelPackageName": "",
  "ModelPackageGroupName": "",
  "ModelPackageDescription": "",
  "InferenceSpecification": "",
  "ValidationSpecification": "",
  "SourceAlgorithmSpecification": "",
  "CertifyForMarketplace": "",
  "Tags": "",
  "ModelApprovalStatus": "",
  "MetadataProperties": {
    "CommitId": "",
    "Repository": "",
    "GeneratedBy": "",
    "ProjectId": ""
  },
  "ModelMetrics": "",
  "ClientToken": "",
  "CustomerMetadataProperties": "",
  "DriftCheckBaselines": "",
  "Domain": "",
  "Task": "",
  "SamplePayloadUrl": "",
  "AdditionalInferenceSpecifications": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackage' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ModelPackageName": "",\n  "ModelPackageGroupName": "",\n  "ModelPackageDescription": "",\n  "InferenceSpecification": "",\n  "ValidationSpecification": "",\n  "SourceAlgorithmSpecification": "",\n  "CertifyForMarketplace": "",\n  "Tags": "",\n  "ModelApprovalStatus": "",\n  "MetadataProperties": {\n    "CommitId": "",\n    "Repository": "",\n    "GeneratedBy": "",\n    "ProjectId": ""\n  },\n  "ModelMetrics": "",\n  "ClientToken": "",\n  "CustomerMetadataProperties": "",\n  "DriftCheckBaselines": "",\n  "Domain": "",\n  "Task": "",\n  "SamplePayloadUrl": "",\n  "AdditionalInferenceSpecifications": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackage'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ModelPackageName": "",
  "ModelPackageGroupName": "",
  "ModelPackageDescription": "",
  "InferenceSpecification": "",
  "ValidationSpecification": "",
  "SourceAlgorithmSpecification": "",
  "CertifyForMarketplace": "",
  "Tags": "",
  "ModelApprovalStatus": "",
  "MetadataProperties": [
    "CommitId": "",
    "Repository": "",
    "GeneratedBy": "",
    "ProjectId": ""
  ],
  "ModelMetrics": "",
  "ClientToken": "",
  "CustomerMetadataProperties": "",
  "DriftCheckBaselines": "",
  "Domain": "",
  "Task": "",
  "SamplePayloadUrl": "",
  "AdditionalInferenceSpecifications": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackage")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackageGroup");

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  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageGroupDescription\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackageGroup" {:headers {:x-amz-target ""}
                                                                                            :content-type :json
                                                                                            :form-params {:ModelPackageGroupName ""
                                                                                                          :ModelPackageGroupDescription ""
                                                                                                          :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackageGroup"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageGroupDescription\": \"\",\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=SageMaker.CreateModelPackageGroup"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageGroupDescription\": \"\",\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=SageMaker.CreateModelPackageGroup");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageGroupDescription\": \"\",\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=SageMaker.CreateModelPackageGroup"

	payload := strings.NewReader("{\n  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageGroupDescription\": \"\",\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: 85

{
  "ModelPackageGroupName": "",
  "ModelPackageGroupDescription": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackageGroup")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageGroupDescription\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackageGroup"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageGroupDescription\": \"\",\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  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageGroupDescription\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackageGroup")
  .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=SageMaker.CreateModelPackageGroup")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageGroupDescription\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ModelPackageGroupName: '',
  ModelPackageGroupDescription: '',
  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=SageMaker.CreateModelPackageGroup');
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=SageMaker.CreateModelPackageGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ModelPackageGroupName: '', ModelPackageGroupDescription: '', Tags: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackageGroup';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ModelPackageGroupName":"","ModelPackageGroupDescription":"","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=SageMaker.CreateModelPackageGroup',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ModelPackageGroupName": "",\n  "ModelPackageGroupDescription": "",\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  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageGroupDescription\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackageGroup")
  .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({ModelPackageGroupName: '', ModelPackageGroupDescription: '', Tags: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackageGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ModelPackageGroupName: '', ModelPackageGroupDescription: '', 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=SageMaker.CreateModelPackageGroup');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ModelPackageGroupName: '',
  ModelPackageGroupDescription: '',
  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=SageMaker.CreateModelPackageGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ModelPackageGroupName: '', ModelPackageGroupDescription: '', 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=SageMaker.CreateModelPackageGroup';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ModelPackageGroupName":"","ModelPackageGroupDescription":"","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 = @{ @"ModelPackageGroupName": @"",
                              @"ModelPackageGroupDescription": @"",
                              @"Tags": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackageGroup"]
                                                       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=SageMaker.CreateModelPackageGroup" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageGroupDescription\": \"\",\n  \"Tags\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackageGroup",
  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([
    'ModelPackageGroupName' => '',
    'ModelPackageGroupDescription' => '',
    '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=SageMaker.CreateModelPackageGroup', [
  'body' => '{
  "ModelPackageGroupName": "",
  "ModelPackageGroupDescription": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackageGroup');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ModelPackageGroupName' => '',
  'ModelPackageGroupDescription' => '',
  'Tags' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ModelPackageGroupName' => '',
  'ModelPackageGroupDescription' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackageGroup');
$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=SageMaker.CreateModelPackageGroup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ModelPackageGroupName": "",
  "ModelPackageGroupDescription": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackageGroup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ModelPackageGroupName": "",
  "ModelPackageGroupDescription": "",
  "Tags": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageGroupDescription\": \"\",\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=SageMaker.CreateModelPackageGroup"

payload = {
    "ModelPackageGroupName": "",
    "ModelPackageGroupDescription": "",
    "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=SageMaker.CreateModelPackageGroup"

payload <- "{\n  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageGroupDescription\": \"\",\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=SageMaker.CreateModelPackageGroup")

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  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageGroupDescription\": \"\",\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  \"ModelPackageGroupName\": \"\",\n  \"ModelPackageGroupDescription\": \"\",\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=SageMaker.CreateModelPackageGroup";

    let payload = json!({
        "ModelPackageGroupName": "",
        "ModelPackageGroupDescription": "",
        "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);
}

echo '{
  "ModelPackageGroupName": "",
  "ModelPackageGroupDescription": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackageGroup' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ModelPackageGroupName": "",\n  "ModelPackageGroupDescription": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackageGroup'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ModelPackageGroupName": "",
  "ModelPackageGroupDescription": "",
  "Tags": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelPackageGroup")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelQualityJobDefinition");

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  \"JobDefinitionName\": \"\",\n  \"ModelQualityBaselineConfig\": \"\",\n  \"ModelQualityAppSpecification\": \"\",\n  \"ModelQualityJobInput\": \"\",\n  \"ModelQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelQualityJobDefinition" {:headers {:x-amz-target ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:JobDefinitionName ""
                                                                                                                  :ModelQualityBaselineConfig ""
                                                                                                                  :ModelQualityAppSpecification ""
                                                                                                                  :ModelQualityJobInput ""
                                                                                                                  :ModelQualityJobOutputConfig {:MonitoringOutputs ""
                                                                                                                                                :KmsKeyId ""}
                                                                                                                  :JobResources {:ClusterConfig ""}
                                                                                                                  :NetworkConfig ""
                                                                                                                  :RoleArn ""
                                                                                                                  :StoppingCondition {:MaxRuntimeInSeconds ""}
                                                                                                                  :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelQualityJobDefinition"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"JobDefinitionName\": \"\",\n  \"ModelQualityBaselineConfig\": \"\",\n  \"ModelQualityAppSpecification\": \"\",\n  \"ModelQualityJobInput\": \"\",\n  \"ModelQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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=SageMaker.CreateModelQualityJobDefinition"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"JobDefinitionName\": \"\",\n  \"ModelQualityBaselineConfig\": \"\",\n  \"ModelQualityAppSpecification\": \"\",\n  \"ModelQualityJobInput\": \"\",\n  \"ModelQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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=SageMaker.CreateModelQualityJobDefinition");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"JobDefinitionName\": \"\",\n  \"ModelQualityBaselineConfig\": \"\",\n  \"ModelQualityAppSpecification\": \"\",\n  \"ModelQualityJobInput\": \"\",\n  \"ModelQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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=SageMaker.CreateModelQualityJobDefinition"

	payload := strings.NewReader("{\n  \"JobDefinitionName\": \"\",\n  \"ModelQualityBaselineConfig\": \"\",\n  \"ModelQualityAppSpecification\": \"\",\n  \"ModelQualityJobInput\": \"\",\n  \"ModelQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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: 384

{
  "JobDefinitionName": "",
  "ModelQualityBaselineConfig": "",
  "ModelQualityAppSpecification": "",
  "ModelQualityJobInput": "",
  "ModelQualityJobOutputConfig": {
    "MonitoringOutputs": "",
    "KmsKeyId": ""
  },
  "JobResources": {
    "ClusterConfig": ""
  },
  "NetworkConfig": "",
  "RoleArn": "",
  "StoppingCondition": {
    "MaxRuntimeInSeconds": ""
  },
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelQualityJobDefinition")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"JobDefinitionName\": \"\",\n  \"ModelQualityBaselineConfig\": \"\",\n  \"ModelQualityAppSpecification\": \"\",\n  \"ModelQualityJobInput\": \"\",\n  \"ModelQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelQualityJobDefinition"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"JobDefinitionName\": \"\",\n  \"ModelQualityBaselineConfig\": \"\",\n  \"ModelQualityAppSpecification\": \"\",\n  \"ModelQualityJobInput\": \"\",\n  \"ModelQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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  \"JobDefinitionName\": \"\",\n  \"ModelQualityBaselineConfig\": \"\",\n  \"ModelQualityAppSpecification\": \"\",\n  \"ModelQualityJobInput\": \"\",\n  \"ModelQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelQualityJobDefinition")
  .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=SageMaker.CreateModelQualityJobDefinition")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"JobDefinitionName\": \"\",\n  \"ModelQualityBaselineConfig\": \"\",\n  \"ModelQualityAppSpecification\": \"\",\n  \"ModelQualityJobInput\": \"\",\n  \"ModelQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  JobDefinitionName: '',
  ModelQualityBaselineConfig: '',
  ModelQualityAppSpecification: '',
  ModelQualityJobInput: '',
  ModelQualityJobOutputConfig: {
    MonitoringOutputs: '',
    KmsKeyId: ''
  },
  JobResources: {
    ClusterConfig: ''
  },
  NetworkConfig: '',
  RoleArn: '',
  StoppingCondition: {
    MaxRuntimeInSeconds: ''
  },
  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=SageMaker.CreateModelQualityJobDefinition');
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=SageMaker.CreateModelQualityJobDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    JobDefinitionName: '',
    ModelQualityBaselineConfig: '',
    ModelQualityAppSpecification: '',
    ModelQualityJobInput: '',
    ModelQualityJobOutputConfig: {MonitoringOutputs: '', KmsKeyId: ''},
    JobResources: {ClusterConfig: ''},
    NetworkConfig: '',
    RoleArn: '',
    StoppingCondition: {MaxRuntimeInSeconds: ''},
    Tags: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelQualityJobDefinition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"JobDefinitionName":"","ModelQualityBaselineConfig":"","ModelQualityAppSpecification":"","ModelQualityJobInput":"","ModelQualityJobOutputConfig":{"MonitoringOutputs":"","KmsKeyId":""},"JobResources":{"ClusterConfig":""},"NetworkConfig":"","RoleArn":"","StoppingCondition":{"MaxRuntimeInSeconds":""},"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=SageMaker.CreateModelQualityJobDefinition',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "JobDefinitionName": "",\n  "ModelQualityBaselineConfig": "",\n  "ModelQualityAppSpecification": "",\n  "ModelQualityJobInput": "",\n  "ModelQualityJobOutputConfig": {\n    "MonitoringOutputs": "",\n    "KmsKeyId": ""\n  },\n  "JobResources": {\n    "ClusterConfig": ""\n  },\n  "NetworkConfig": "",\n  "RoleArn": "",\n  "StoppingCondition": {\n    "MaxRuntimeInSeconds": ""\n  },\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  \"JobDefinitionName\": \"\",\n  \"ModelQualityBaselineConfig\": \"\",\n  \"ModelQualityAppSpecification\": \"\",\n  \"ModelQualityJobInput\": \"\",\n  \"ModelQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelQualityJobDefinition")
  .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({
  JobDefinitionName: '',
  ModelQualityBaselineConfig: '',
  ModelQualityAppSpecification: '',
  ModelQualityJobInput: '',
  ModelQualityJobOutputConfig: {MonitoringOutputs: '', KmsKeyId: ''},
  JobResources: {ClusterConfig: ''},
  NetworkConfig: '',
  RoleArn: '',
  StoppingCondition: {MaxRuntimeInSeconds: ''},
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelQualityJobDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    JobDefinitionName: '',
    ModelQualityBaselineConfig: '',
    ModelQualityAppSpecification: '',
    ModelQualityJobInput: '',
    ModelQualityJobOutputConfig: {MonitoringOutputs: '', KmsKeyId: ''},
    JobResources: {ClusterConfig: ''},
    NetworkConfig: '',
    RoleArn: '',
    StoppingCondition: {MaxRuntimeInSeconds: ''},
    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=SageMaker.CreateModelQualityJobDefinition');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  JobDefinitionName: '',
  ModelQualityBaselineConfig: '',
  ModelQualityAppSpecification: '',
  ModelQualityJobInput: '',
  ModelQualityJobOutputConfig: {
    MonitoringOutputs: '',
    KmsKeyId: ''
  },
  JobResources: {
    ClusterConfig: ''
  },
  NetworkConfig: '',
  RoleArn: '',
  StoppingCondition: {
    MaxRuntimeInSeconds: ''
  },
  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=SageMaker.CreateModelQualityJobDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    JobDefinitionName: '',
    ModelQualityBaselineConfig: '',
    ModelQualityAppSpecification: '',
    ModelQualityJobInput: '',
    ModelQualityJobOutputConfig: {MonitoringOutputs: '', KmsKeyId: ''},
    JobResources: {ClusterConfig: ''},
    NetworkConfig: '',
    RoleArn: '',
    StoppingCondition: {MaxRuntimeInSeconds: ''},
    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=SageMaker.CreateModelQualityJobDefinition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"JobDefinitionName":"","ModelQualityBaselineConfig":"","ModelQualityAppSpecification":"","ModelQualityJobInput":"","ModelQualityJobOutputConfig":{"MonitoringOutputs":"","KmsKeyId":""},"JobResources":{"ClusterConfig":""},"NetworkConfig":"","RoleArn":"","StoppingCondition":{"MaxRuntimeInSeconds":""},"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 = @{ @"JobDefinitionName": @"",
                              @"ModelQualityBaselineConfig": @"",
                              @"ModelQualityAppSpecification": @"",
                              @"ModelQualityJobInput": @"",
                              @"ModelQualityJobOutputConfig": @{ @"MonitoringOutputs": @"", @"KmsKeyId": @"" },
                              @"JobResources": @{ @"ClusterConfig": @"" },
                              @"NetworkConfig": @"",
                              @"RoleArn": @"",
                              @"StoppingCondition": @{ @"MaxRuntimeInSeconds": @"" },
                              @"Tags": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelQualityJobDefinition"]
                                                       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=SageMaker.CreateModelQualityJobDefinition" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"JobDefinitionName\": \"\",\n  \"ModelQualityBaselineConfig\": \"\",\n  \"ModelQualityAppSpecification\": \"\",\n  \"ModelQualityJobInput\": \"\",\n  \"ModelQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\n  \"Tags\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelQualityJobDefinition",
  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([
    'JobDefinitionName' => '',
    'ModelQualityBaselineConfig' => '',
    'ModelQualityAppSpecification' => '',
    'ModelQualityJobInput' => '',
    'ModelQualityJobOutputConfig' => [
        'MonitoringOutputs' => '',
        'KmsKeyId' => ''
    ],
    'JobResources' => [
        'ClusterConfig' => ''
    ],
    'NetworkConfig' => '',
    'RoleArn' => '',
    'StoppingCondition' => [
        'MaxRuntimeInSeconds' => ''
    ],
    '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=SageMaker.CreateModelQualityJobDefinition', [
  'body' => '{
  "JobDefinitionName": "",
  "ModelQualityBaselineConfig": "",
  "ModelQualityAppSpecification": "",
  "ModelQualityJobInput": "",
  "ModelQualityJobOutputConfig": {
    "MonitoringOutputs": "",
    "KmsKeyId": ""
  },
  "JobResources": {
    "ClusterConfig": ""
  },
  "NetworkConfig": "",
  "RoleArn": "",
  "StoppingCondition": {
    "MaxRuntimeInSeconds": ""
  },
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelQualityJobDefinition');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'JobDefinitionName' => '',
  'ModelQualityBaselineConfig' => '',
  'ModelQualityAppSpecification' => '',
  'ModelQualityJobInput' => '',
  'ModelQualityJobOutputConfig' => [
    'MonitoringOutputs' => '',
    'KmsKeyId' => ''
  ],
  'JobResources' => [
    'ClusterConfig' => ''
  ],
  'NetworkConfig' => '',
  'RoleArn' => '',
  'StoppingCondition' => [
    'MaxRuntimeInSeconds' => ''
  ],
  'Tags' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'JobDefinitionName' => '',
  'ModelQualityBaselineConfig' => '',
  'ModelQualityAppSpecification' => '',
  'ModelQualityJobInput' => '',
  'ModelQualityJobOutputConfig' => [
    'MonitoringOutputs' => '',
    'KmsKeyId' => ''
  ],
  'JobResources' => [
    'ClusterConfig' => ''
  ],
  'NetworkConfig' => '',
  'RoleArn' => '',
  'StoppingCondition' => [
    'MaxRuntimeInSeconds' => ''
  ],
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelQualityJobDefinition');
$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=SageMaker.CreateModelQualityJobDefinition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "JobDefinitionName": "",
  "ModelQualityBaselineConfig": "",
  "ModelQualityAppSpecification": "",
  "ModelQualityJobInput": "",
  "ModelQualityJobOutputConfig": {
    "MonitoringOutputs": "",
    "KmsKeyId": ""
  },
  "JobResources": {
    "ClusterConfig": ""
  },
  "NetworkConfig": "",
  "RoleArn": "",
  "StoppingCondition": {
    "MaxRuntimeInSeconds": ""
  },
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelQualityJobDefinition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "JobDefinitionName": "",
  "ModelQualityBaselineConfig": "",
  "ModelQualityAppSpecification": "",
  "ModelQualityJobInput": "",
  "ModelQualityJobOutputConfig": {
    "MonitoringOutputs": "",
    "KmsKeyId": ""
  },
  "JobResources": {
    "ClusterConfig": ""
  },
  "NetworkConfig": "",
  "RoleArn": "",
  "StoppingCondition": {
    "MaxRuntimeInSeconds": ""
  },
  "Tags": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"JobDefinitionName\": \"\",\n  \"ModelQualityBaselineConfig\": \"\",\n  \"ModelQualityAppSpecification\": \"\",\n  \"ModelQualityJobInput\": \"\",\n  \"ModelQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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=SageMaker.CreateModelQualityJobDefinition"

payload = {
    "JobDefinitionName": "",
    "ModelQualityBaselineConfig": "",
    "ModelQualityAppSpecification": "",
    "ModelQualityJobInput": "",
    "ModelQualityJobOutputConfig": {
        "MonitoringOutputs": "",
        "KmsKeyId": ""
    },
    "JobResources": { "ClusterConfig": "" },
    "NetworkConfig": "",
    "RoleArn": "",
    "StoppingCondition": { "MaxRuntimeInSeconds": "" },
    "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=SageMaker.CreateModelQualityJobDefinition"

payload <- "{\n  \"JobDefinitionName\": \"\",\n  \"ModelQualityBaselineConfig\": \"\",\n  \"ModelQualityAppSpecification\": \"\",\n  \"ModelQualityJobInput\": \"\",\n  \"ModelQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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=SageMaker.CreateModelQualityJobDefinition")

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  \"JobDefinitionName\": \"\",\n  \"ModelQualityBaselineConfig\": \"\",\n  \"ModelQualityAppSpecification\": \"\",\n  \"ModelQualityJobInput\": \"\",\n  \"ModelQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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  \"JobDefinitionName\": \"\",\n  \"ModelQualityBaselineConfig\": \"\",\n  \"ModelQualityAppSpecification\": \"\",\n  \"ModelQualityJobInput\": \"\",\n  \"ModelQualityJobOutputConfig\": {\n    \"MonitoringOutputs\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"JobResources\": {\n    \"ClusterConfig\": \"\"\n  },\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"StoppingCondition\": {\n    \"MaxRuntimeInSeconds\": \"\"\n  },\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=SageMaker.CreateModelQualityJobDefinition";

    let payload = json!({
        "JobDefinitionName": "",
        "ModelQualityBaselineConfig": "",
        "ModelQualityAppSpecification": "",
        "ModelQualityJobInput": "",
        "ModelQualityJobOutputConfig": json!({
            "MonitoringOutputs": "",
            "KmsKeyId": ""
        }),
        "JobResources": json!({"ClusterConfig": ""}),
        "NetworkConfig": "",
        "RoleArn": "",
        "StoppingCondition": json!({"MaxRuntimeInSeconds": ""}),
        "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);
}

echo '{
  "JobDefinitionName": "",
  "ModelQualityBaselineConfig": "",
  "ModelQualityAppSpecification": "",
  "ModelQualityJobInput": "",
  "ModelQualityJobOutputConfig": {
    "MonitoringOutputs": "",
    "KmsKeyId": ""
  },
  "JobResources": {
    "ClusterConfig": ""
  },
  "NetworkConfig": "",
  "RoleArn": "",
  "StoppingCondition": {
    "MaxRuntimeInSeconds": ""
  },
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelQualityJobDefinition' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "JobDefinitionName": "",\n  "ModelQualityBaselineConfig": "",\n  "ModelQualityAppSpecification": "",\n  "ModelQualityJobInput": "",\n  "ModelQualityJobOutputConfig": {\n    "MonitoringOutputs": "",\n    "KmsKeyId": ""\n  },\n  "JobResources": {\n    "ClusterConfig": ""\n  },\n  "NetworkConfig": "",\n  "RoleArn": "",\n  "StoppingCondition": {\n    "MaxRuntimeInSeconds": ""\n  },\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelQualityJobDefinition'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "JobDefinitionName": "",
  "ModelQualityBaselineConfig": "",
  "ModelQualityAppSpecification": "",
  "ModelQualityJobInput": "",
  "ModelQualityJobOutputConfig": [
    "MonitoringOutputs": "",
    "KmsKeyId": ""
  ],
  "JobResources": ["ClusterConfig": ""],
  "NetworkConfig": "",
  "RoleArn": "",
  "StoppingCondition": ["MaxRuntimeInSeconds": ""],
  "Tags": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateModelQualityJobDefinition")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateMonitoringSchedule");

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  \"MonitoringScheduleName\": \"\",\n  \"MonitoringScheduleConfig\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateMonitoringSchedule" {:headers {:x-amz-target ""}
                                                                                             :content-type :json
                                                                                             :form-params {:MonitoringScheduleName ""
                                                                                                           :MonitoringScheduleConfig ""
                                                                                                           :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateMonitoringSchedule"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"MonitoringScheduleName\": \"\",\n  \"MonitoringScheduleConfig\": \"\",\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=SageMaker.CreateMonitoringSchedule"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"MonitoringScheduleName\": \"\",\n  \"MonitoringScheduleConfig\": \"\",\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=SageMaker.CreateMonitoringSchedule");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"MonitoringScheduleName\": \"\",\n  \"MonitoringScheduleConfig\": \"\",\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=SageMaker.CreateMonitoringSchedule"

	payload := strings.NewReader("{\n  \"MonitoringScheduleName\": \"\",\n  \"MonitoringScheduleConfig\": \"\",\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: 82

{
  "MonitoringScheduleName": "",
  "MonitoringScheduleConfig": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateMonitoringSchedule")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"MonitoringScheduleName\": \"\",\n  \"MonitoringScheduleConfig\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateMonitoringSchedule"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"MonitoringScheduleName\": \"\",\n  \"MonitoringScheduleConfig\": \"\",\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  \"MonitoringScheduleName\": \"\",\n  \"MonitoringScheduleConfig\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateMonitoringSchedule")
  .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=SageMaker.CreateMonitoringSchedule")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"MonitoringScheduleName\": \"\",\n  \"MonitoringScheduleConfig\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  MonitoringScheduleName: '',
  MonitoringScheduleConfig: '',
  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=SageMaker.CreateMonitoringSchedule');
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=SageMaker.CreateMonitoringSchedule',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {MonitoringScheduleName: '', MonitoringScheduleConfig: '', Tags: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateMonitoringSchedule';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"MonitoringScheduleName":"","MonitoringScheduleConfig":"","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=SageMaker.CreateMonitoringSchedule',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "MonitoringScheduleName": "",\n  "MonitoringScheduleConfig": "",\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  \"MonitoringScheduleName\": \"\",\n  \"MonitoringScheduleConfig\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateMonitoringSchedule")
  .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({MonitoringScheduleName: '', MonitoringScheduleConfig: '', Tags: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateMonitoringSchedule',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {MonitoringScheduleName: '', MonitoringScheduleConfig: '', 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=SageMaker.CreateMonitoringSchedule');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  MonitoringScheduleName: '',
  MonitoringScheduleConfig: '',
  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=SageMaker.CreateMonitoringSchedule',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {MonitoringScheduleName: '', MonitoringScheduleConfig: '', 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=SageMaker.CreateMonitoringSchedule';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"MonitoringScheduleName":"","MonitoringScheduleConfig":"","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 = @{ @"MonitoringScheduleName": @"",
                              @"MonitoringScheduleConfig": @"",
                              @"Tags": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreateMonitoringSchedule"]
                                                       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=SageMaker.CreateMonitoringSchedule" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"MonitoringScheduleName\": \"\",\n  \"MonitoringScheduleConfig\": \"\",\n  \"Tags\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateMonitoringSchedule",
  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([
    'MonitoringScheduleName' => '',
    'MonitoringScheduleConfig' => '',
    '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=SageMaker.CreateMonitoringSchedule', [
  'body' => '{
  "MonitoringScheduleName": "",
  "MonitoringScheduleConfig": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateMonitoringSchedule');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'MonitoringScheduleName' => '',
  'MonitoringScheduleConfig' => '',
  'Tags' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'MonitoringScheduleName' => '',
  'MonitoringScheduleConfig' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateMonitoringSchedule');
$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=SageMaker.CreateMonitoringSchedule' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MonitoringScheduleName": "",
  "MonitoringScheduleConfig": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateMonitoringSchedule' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MonitoringScheduleName": "",
  "MonitoringScheduleConfig": "",
  "Tags": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"MonitoringScheduleName\": \"\",\n  \"MonitoringScheduleConfig\": \"\",\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=SageMaker.CreateMonitoringSchedule"

payload = {
    "MonitoringScheduleName": "",
    "MonitoringScheduleConfig": "",
    "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=SageMaker.CreateMonitoringSchedule"

payload <- "{\n  \"MonitoringScheduleName\": \"\",\n  \"MonitoringScheduleConfig\": \"\",\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=SageMaker.CreateMonitoringSchedule")

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  \"MonitoringScheduleName\": \"\",\n  \"MonitoringScheduleConfig\": \"\",\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  \"MonitoringScheduleName\": \"\",\n  \"MonitoringScheduleConfig\": \"\",\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=SageMaker.CreateMonitoringSchedule";

    let payload = json!({
        "MonitoringScheduleName": "",
        "MonitoringScheduleConfig": "",
        "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);
}

echo '{
  "MonitoringScheduleName": "",
  "MonitoringScheduleConfig": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateMonitoringSchedule' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "MonitoringScheduleName": "",\n  "MonitoringScheduleConfig": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateMonitoringSchedule'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "MonitoringScheduleName": "",
  "MonitoringScheduleConfig": "",
  "Tags": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateMonitoringSchedule")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstance");

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  \"NotebookInstanceName\": \"\",\n  \"InstanceType\": \"\",\n  \"SubnetId\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"RoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"LifecycleConfigName\": \"\",\n  \"DirectInternetAccess\": \"\",\n  \"VolumeSizeInGB\": \"\",\n  \"AcceleratorTypes\": \"\",\n  \"DefaultCodeRepository\": \"\",\n  \"AdditionalCodeRepositories\": \"\",\n  \"RootAccess\": \"\",\n  \"PlatformIdentifier\": \"\",\n  \"InstanceMetadataServiceConfiguration\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstance" {:headers {:x-amz-target ""}
                                                                                           :content-type :json
                                                                                           :form-params {:NotebookInstanceName ""
                                                                                                         :InstanceType ""
                                                                                                         :SubnetId ""
                                                                                                         :SecurityGroupIds ""
                                                                                                         :RoleArn ""
                                                                                                         :KmsKeyId ""
                                                                                                         :Tags ""
                                                                                                         :LifecycleConfigName ""
                                                                                                         :DirectInternetAccess ""
                                                                                                         :VolumeSizeInGB ""
                                                                                                         :AcceleratorTypes ""
                                                                                                         :DefaultCodeRepository ""
                                                                                                         :AdditionalCodeRepositories ""
                                                                                                         :RootAccess ""
                                                                                                         :PlatformIdentifier ""
                                                                                                         :InstanceMetadataServiceConfiguration ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstance"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"NotebookInstanceName\": \"\",\n  \"InstanceType\": \"\",\n  \"SubnetId\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"RoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"LifecycleConfigName\": \"\",\n  \"DirectInternetAccess\": \"\",\n  \"VolumeSizeInGB\": \"\",\n  \"AcceleratorTypes\": \"\",\n  \"DefaultCodeRepository\": \"\",\n  \"AdditionalCodeRepositories\": \"\",\n  \"RootAccess\": \"\",\n  \"PlatformIdentifier\": \"\",\n  \"InstanceMetadataServiceConfiguration\": \"\"\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=SageMaker.CreateNotebookInstance"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"NotebookInstanceName\": \"\",\n  \"InstanceType\": \"\",\n  \"SubnetId\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"RoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"LifecycleConfigName\": \"\",\n  \"DirectInternetAccess\": \"\",\n  \"VolumeSizeInGB\": \"\",\n  \"AcceleratorTypes\": \"\",\n  \"DefaultCodeRepository\": \"\",\n  \"AdditionalCodeRepositories\": \"\",\n  \"RootAccess\": \"\",\n  \"PlatformIdentifier\": \"\",\n  \"InstanceMetadataServiceConfiguration\": \"\"\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=SageMaker.CreateNotebookInstance");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"NotebookInstanceName\": \"\",\n  \"InstanceType\": \"\",\n  \"SubnetId\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"RoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"LifecycleConfigName\": \"\",\n  \"DirectInternetAccess\": \"\",\n  \"VolumeSizeInGB\": \"\",\n  \"AcceleratorTypes\": \"\",\n  \"DefaultCodeRepository\": \"\",\n  \"AdditionalCodeRepositories\": \"\",\n  \"RootAccess\": \"\",\n  \"PlatformIdentifier\": \"\",\n  \"InstanceMetadataServiceConfiguration\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstance"

	payload := strings.NewReader("{\n  \"NotebookInstanceName\": \"\",\n  \"InstanceType\": \"\",\n  \"SubnetId\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"RoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"LifecycleConfigName\": \"\",\n  \"DirectInternetAccess\": \"\",\n  \"VolumeSizeInGB\": \"\",\n  \"AcceleratorTypes\": \"\",\n  \"DefaultCodeRepository\": \"\",\n  \"AdditionalCodeRepositories\": \"\",\n  \"RootAccess\": \"\",\n  \"PlatformIdentifier\": \"\",\n  \"InstanceMetadataServiceConfiguration\": \"\"\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: 417

{
  "NotebookInstanceName": "",
  "InstanceType": "",
  "SubnetId": "",
  "SecurityGroupIds": "",
  "RoleArn": "",
  "KmsKeyId": "",
  "Tags": "",
  "LifecycleConfigName": "",
  "DirectInternetAccess": "",
  "VolumeSizeInGB": "",
  "AcceleratorTypes": "",
  "DefaultCodeRepository": "",
  "AdditionalCodeRepositories": "",
  "RootAccess": "",
  "PlatformIdentifier": "",
  "InstanceMetadataServiceConfiguration": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstance")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"NotebookInstanceName\": \"\",\n  \"InstanceType\": \"\",\n  \"SubnetId\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"RoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"LifecycleConfigName\": \"\",\n  \"DirectInternetAccess\": \"\",\n  \"VolumeSizeInGB\": \"\",\n  \"AcceleratorTypes\": \"\",\n  \"DefaultCodeRepository\": \"\",\n  \"AdditionalCodeRepositories\": \"\",\n  \"RootAccess\": \"\",\n  \"PlatformIdentifier\": \"\",\n  \"InstanceMetadataServiceConfiguration\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstance"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"NotebookInstanceName\": \"\",\n  \"InstanceType\": \"\",\n  \"SubnetId\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"RoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"LifecycleConfigName\": \"\",\n  \"DirectInternetAccess\": \"\",\n  \"VolumeSizeInGB\": \"\",\n  \"AcceleratorTypes\": \"\",\n  \"DefaultCodeRepository\": \"\",\n  \"AdditionalCodeRepositories\": \"\",\n  \"RootAccess\": \"\",\n  \"PlatformIdentifier\": \"\",\n  \"InstanceMetadataServiceConfiguration\": \"\"\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  \"NotebookInstanceName\": \"\",\n  \"InstanceType\": \"\",\n  \"SubnetId\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"RoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"LifecycleConfigName\": \"\",\n  \"DirectInternetAccess\": \"\",\n  \"VolumeSizeInGB\": \"\",\n  \"AcceleratorTypes\": \"\",\n  \"DefaultCodeRepository\": \"\",\n  \"AdditionalCodeRepositories\": \"\",\n  \"RootAccess\": \"\",\n  \"PlatformIdentifier\": \"\",\n  \"InstanceMetadataServiceConfiguration\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstance")
  .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=SageMaker.CreateNotebookInstance")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"NotebookInstanceName\": \"\",\n  \"InstanceType\": \"\",\n  \"SubnetId\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"RoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"LifecycleConfigName\": \"\",\n  \"DirectInternetAccess\": \"\",\n  \"VolumeSizeInGB\": \"\",\n  \"AcceleratorTypes\": \"\",\n  \"DefaultCodeRepository\": \"\",\n  \"AdditionalCodeRepositories\": \"\",\n  \"RootAccess\": \"\",\n  \"PlatformIdentifier\": \"\",\n  \"InstanceMetadataServiceConfiguration\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  NotebookInstanceName: '',
  InstanceType: '',
  SubnetId: '',
  SecurityGroupIds: '',
  RoleArn: '',
  KmsKeyId: '',
  Tags: '',
  LifecycleConfigName: '',
  DirectInternetAccess: '',
  VolumeSizeInGB: '',
  AcceleratorTypes: '',
  DefaultCodeRepository: '',
  AdditionalCodeRepositories: '',
  RootAccess: '',
  PlatformIdentifier: '',
  InstanceMetadataServiceConfiguration: ''
});

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=SageMaker.CreateNotebookInstance');
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=SageMaker.CreateNotebookInstance',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    NotebookInstanceName: '',
    InstanceType: '',
    SubnetId: '',
    SecurityGroupIds: '',
    RoleArn: '',
    KmsKeyId: '',
    Tags: '',
    LifecycleConfigName: '',
    DirectInternetAccess: '',
    VolumeSizeInGB: '',
    AcceleratorTypes: '',
    DefaultCodeRepository: '',
    AdditionalCodeRepositories: '',
    RootAccess: '',
    PlatformIdentifier: '',
    InstanceMetadataServiceConfiguration: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstance';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"NotebookInstanceName":"","InstanceType":"","SubnetId":"","SecurityGroupIds":"","RoleArn":"","KmsKeyId":"","Tags":"","LifecycleConfigName":"","DirectInternetAccess":"","VolumeSizeInGB":"","AcceleratorTypes":"","DefaultCodeRepository":"","AdditionalCodeRepositories":"","RootAccess":"","PlatformIdentifier":"","InstanceMetadataServiceConfiguration":""}'
};

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=SageMaker.CreateNotebookInstance',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "NotebookInstanceName": "",\n  "InstanceType": "",\n  "SubnetId": "",\n  "SecurityGroupIds": "",\n  "RoleArn": "",\n  "KmsKeyId": "",\n  "Tags": "",\n  "LifecycleConfigName": "",\n  "DirectInternetAccess": "",\n  "VolumeSizeInGB": "",\n  "AcceleratorTypes": "",\n  "DefaultCodeRepository": "",\n  "AdditionalCodeRepositories": "",\n  "RootAccess": "",\n  "PlatformIdentifier": "",\n  "InstanceMetadataServiceConfiguration": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"NotebookInstanceName\": \"\",\n  \"InstanceType\": \"\",\n  \"SubnetId\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"RoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"LifecycleConfigName\": \"\",\n  \"DirectInternetAccess\": \"\",\n  \"VolumeSizeInGB\": \"\",\n  \"AcceleratorTypes\": \"\",\n  \"DefaultCodeRepository\": \"\",\n  \"AdditionalCodeRepositories\": \"\",\n  \"RootAccess\": \"\",\n  \"PlatformIdentifier\": \"\",\n  \"InstanceMetadataServiceConfiguration\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstance")
  .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({
  NotebookInstanceName: '',
  InstanceType: '',
  SubnetId: '',
  SecurityGroupIds: '',
  RoleArn: '',
  KmsKeyId: '',
  Tags: '',
  LifecycleConfigName: '',
  DirectInternetAccess: '',
  VolumeSizeInGB: '',
  AcceleratorTypes: '',
  DefaultCodeRepository: '',
  AdditionalCodeRepositories: '',
  RootAccess: '',
  PlatformIdentifier: '',
  InstanceMetadataServiceConfiguration: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstance',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    NotebookInstanceName: '',
    InstanceType: '',
    SubnetId: '',
    SecurityGroupIds: '',
    RoleArn: '',
    KmsKeyId: '',
    Tags: '',
    LifecycleConfigName: '',
    DirectInternetAccess: '',
    VolumeSizeInGB: '',
    AcceleratorTypes: '',
    DefaultCodeRepository: '',
    AdditionalCodeRepositories: '',
    RootAccess: '',
    PlatformIdentifier: '',
    InstanceMetadataServiceConfiguration: ''
  },
  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=SageMaker.CreateNotebookInstance');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  NotebookInstanceName: '',
  InstanceType: '',
  SubnetId: '',
  SecurityGroupIds: '',
  RoleArn: '',
  KmsKeyId: '',
  Tags: '',
  LifecycleConfigName: '',
  DirectInternetAccess: '',
  VolumeSizeInGB: '',
  AcceleratorTypes: '',
  DefaultCodeRepository: '',
  AdditionalCodeRepositories: '',
  RootAccess: '',
  PlatformIdentifier: '',
  InstanceMetadataServiceConfiguration: ''
});

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=SageMaker.CreateNotebookInstance',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    NotebookInstanceName: '',
    InstanceType: '',
    SubnetId: '',
    SecurityGroupIds: '',
    RoleArn: '',
    KmsKeyId: '',
    Tags: '',
    LifecycleConfigName: '',
    DirectInternetAccess: '',
    VolumeSizeInGB: '',
    AcceleratorTypes: '',
    DefaultCodeRepository: '',
    AdditionalCodeRepositories: '',
    RootAccess: '',
    PlatformIdentifier: '',
    InstanceMetadataServiceConfiguration: ''
  }
};

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=SageMaker.CreateNotebookInstance';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"NotebookInstanceName":"","InstanceType":"","SubnetId":"","SecurityGroupIds":"","RoleArn":"","KmsKeyId":"","Tags":"","LifecycleConfigName":"","DirectInternetAccess":"","VolumeSizeInGB":"","AcceleratorTypes":"","DefaultCodeRepository":"","AdditionalCodeRepositories":"","RootAccess":"","PlatformIdentifier":"","InstanceMetadataServiceConfiguration":""}'
};

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 = @{ @"NotebookInstanceName": @"",
                              @"InstanceType": @"",
                              @"SubnetId": @"",
                              @"SecurityGroupIds": @"",
                              @"RoleArn": @"",
                              @"KmsKeyId": @"",
                              @"Tags": @"",
                              @"LifecycleConfigName": @"",
                              @"DirectInternetAccess": @"",
                              @"VolumeSizeInGB": @"",
                              @"AcceleratorTypes": @"",
                              @"DefaultCodeRepository": @"",
                              @"AdditionalCodeRepositories": @"",
                              @"RootAccess": @"",
                              @"PlatformIdentifier": @"",
                              @"InstanceMetadataServiceConfiguration": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstance"]
                                                       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=SageMaker.CreateNotebookInstance" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"NotebookInstanceName\": \"\",\n  \"InstanceType\": \"\",\n  \"SubnetId\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"RoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"LifecycleConfigName\": \"\",\n  \"DirectInternetAccess\": \"\",\n  \"VolumeSizeInGB\": \"\",\n  \"AcceleratorTypes\": \"\",\n  \"DefaultCodeRepository\": \"\",\n  \"AdditionalCodeRepositories\": \"\",\n  \"RootAccess\": \"\",\n  \"PlatformIdentifier\": \"\",\n  \"InstanceMetadataServiceConfiguration\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstance",
  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([
    'NotebookInstanceName' => '',
    'InstanceType' => '',
    'SubnetId' => '',
    'SecurityGroupIds' => '',
    'RoleArn' => '',
    'KmsKeyId' => '',
    'Tags' => '',
    'LifecycleConfigName' => '',
    'DirectInternetAccess' => '',
    'VolumeSizeInGB' => '',
    'AcceleratorTypes' => '',
    'DefaultCodeRepository' => '',
    'AdditionalCodeRepositories' => '',
    'RootAccess' => '',
    'PlatformIdentifier' => '',
    'InstanceMetadataServiceConfiguration' => ''
  ]),
  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=SageMaker.CreateNotebookInstance', [
  'body' => '{
  "NotebookInstanceName": "",
  "InstanceType": "",
  "SubnetId": "",
  "SecurityGroupIds": "",
  "RoleArn": "",
  "KmsKeyId": "",
  "Tags": "",
  "LifecycleConfigName": "",
  "DirectInternetAccess": "",
  "VolumeSizeInGB": "",
  "AcceleratorTypes": "",
  "DefaultCodeRepository": "",
  "AdditionalCodeRepositories": "",
  "RootAccess": "",
  "PlatformIdentifier": "",
  "InstanceMetadataServiceConfiguration": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstance');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'NotebookInstanceName' => '',
  'InstanceType' => '',
  'SubnetId' => '',
  'SecurityGroupIds' => '',
  'RoleArn' => '',
  'KmsKeyId' => '',
  'Tags' => '',
  'LifecycleConfigName' => '',
  'DirectInternetAccess' => '',
  'VolumeSizeInGB' => '',
  'AcceleratorTypes' => '',
  'DefaultCodeRepository' => '',
  'AdditionalCodeRepositories' => '',
  'RootAccess' => '',
  'PlatformIdentifier' => '',
  'InstanceMetadataServiceConfiguration' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'NotebookInstanceName' => '',
  'InstanceType' => '',
  'SubnetId' => '',
  'SecurityGroupIds' => '',
  'RoleArn' => '',
  'KmsKeyId' => '',
  'Tags' => '',
  'LifecycleConfigName' => '',
  'DirectInternetAccess' => '',
  'VolumeSizeInGB' => '',
  'AcceleratorTypes' => '',
  'DefaultCodeRepository' => '',
  'AdditionalCodeRepositories' => '',
  'RootAccess' => '',
  'PlatformIdentifier' => '',
  'InstanceMetadataServiceConfiguration' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstance');
$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=SageMaker.CreateNotebookInstance' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "NotebookInstanceName": "",
  "InstanceType": "",
  "SubnetId": "",
  "SecurityGroupIds": "",
  "RoleArn": "",
  "KmsKeyId": "",
  "Tags": "",
  "LifecycleConfigName": "",
  "DirectInternetAccess": "",
  "VolumeSizeInGB": "",
  "AcceleratorTypes": "",
  "DefaultCodeRepository": "",
  "AdditionalCodeRepositories": "",
  "RootAccess": "",
  "PlatformIdentifier": "",
  "InstanceMetadataServiceConfiguration": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstance' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "NotebookInstanceName": "",
  "InstanceType": "",
  "SubnetId": "",
  "SecurityGroupIds": "",
  "RoleArn": "",
  "KmsKeyId": "",
  "Tags": "",
  "LifecycleConfigName": "",
  "DirectInternetAccess": "",
  "VolumeSizeInGB": "",
  "AcceleratorTypes": "",
  "DefaultCodeRepository": "",
  "AdditionalCodeRepositories": "",
  "RootAccess": "",
  "PlatformIdentifier": "",
  "InstanceMetadataServiceConfiguration": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"NotebookInstanceName\": \"\",\n  \"InstanceType\": \"\",\n  \"SubnetId\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"RoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"LifecycleConfigName\": \"\",\n  \"DirectInternetAccess\": \"\",\n  \"VolumeSizeInGB\": \"\",\n  \"AcceleratorTypes\": \"\",\n  \"DefaultCodeRepository\": \"\",\n  \"AdditionalCodeRepositories\": \"\",\n  \"RootAccess\": \"\",\n  \"PlatformIdentifier\": \"\",\n  \"InstanceMetadataServiceConfiguration\": \"\"\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=SageMaker.CreateNotebookInstance"

payload = {
    "NotebookInstanceName": "",
    "InstanceType": "",
    "SubnetId": "",
    "SecurityGroupIds": "",
    "RoleArn": "",
    "KmsKeyId": "",
    "Tags": "",
    "LifecycleConfigName": "",
    "DirectInternetAccess": "",
    "VolumeSizeInGB": "",
    "AcceleratorTypes": "",
    "DefaultCodeRepository": "",
    "AdditionalCodeRepositories": "",
    "RootAccess": "",
    "PlatformIdentifier": "",
    "InstanceMetadataServiceConfiguration": ""
}
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=SageMaker.CreateNotebookInstance"

payload <- "{\n  \"NotebookInstanceName\": \"\",\n  \"InstanceType\": \"\",\n  \"SubnetId\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"RoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"LifecycleConfigName\": \"\",\n  \"DirectInternetAccess\": \"\",\n  \"VolumeSizeInGB\": \"\",\n  \"AcceleratorTypes\": \"\",\n  \"DefaultCodeRepository\": \"\",\n  \"AdditionalCodeRepositories\": \"\",\n  \"RootAccess\": \"\",\n  \"PlatformIdentifier\": \"\",\n  \"InstanceMetadataServiceConfiguration\": \"\"\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=SageMaker.CreateNotebookInstance")

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  \"NotebookInstanceName\": \"\",\n  \"InstanceType\": \"\",\n  \"SubnetId\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"RoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"LifecycleConfigName\": \"\",\n  \"DirectInternetAccess\": \"\",\n  \"VolumeSizeInGB\": \"\",\n  \"AcceleratorTypes\": \"\",\n  \"DefaultCodeRepository\": \"\",\n  \"AdditionalCodeRepositories\": \"\",\n  \"RootAccess\": \"\",\n  \"PlatformIdentifier\": \"\",\n  \"InstanceMetadataServiceConfiguration\": \"\"\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  \"NotebookInstanceName\": \"\",\n  \"InstanceType\": \"\",\n  \"SubnetId\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"RoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"LifecycleConfigName\": \"\",\n  \"DirectInternetAccess\": \"\",\n  \"VolumeSizeInGB\": \"\",\n  \"AcceleratorTypes\": \"\",\n  \"DefaultCodeRepository\": \"\",\n  \"AdditionalCodeRepositories\": \"\",\n  \"RootAccess\": \"\",\n  \"PlatformIdentifier\": \"\",\n  \"InstanceMetadataServiceConfiguration\": \"\"\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=SageMaker.CreateNotebookInstance";

    let payload = json!({
        "NotebookInstanceName": "",
        "InstanceType": "",
        "SubnetId": "",
        "SecurityGroupIds": "",
        "RoleArn": "",
        "KmsKeyId": "",
        "Tags": "",
        "LifecycleConfigName": "",
        "DirectInternetAccess": "",
        "VolumeSizeInGB": "",
        "AcceleratorTypes": "",
        "DefaultCodeRepository": "",
        "AdditionalCodeRepositories": "",
        "RootAccess": "",
        "PlatformIdentifier": "",
        "InstanceMetadataServiceConfiguration": ""
    });

    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);
}

echo '{
  "NotebookInstanceName": "",
  "InstanceType": "",
  "SubnetId": "",
  "SecurityGroupIds": "",
  "RoleArn": "",
  "KmsKeyId": "",
  "Tags": "",
  "LifecycleConfigName": "",
  "DirectInternetAccess": "",
  "VolumeSizeInGB": "",
  "AcceleratorTypes": "",
  "DefaultCodeRepository": "",
  "AdditionalCodeRepositories": "",
  "RootAccess": "",
  "PlatformIdentifier": "",
  "InstanceMetadataServiceConfiguration": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstance' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "NotebookInstanceName": "",\n  "InstanceType": "",\n  "SubnetId": "",\n  "SecurityGroupIds": "",\n  "RoleArn": "",\n  "KmsKeyId": "",\n  "Tags": "",\n  "LifecycleConfigName": "",\n  "DirectInternetAccess": "",\n  "VolumeSizeInGB": "",\n  "AcceleratorTypes": "",\n  "DefaultCodeRepository": "",\n  "AdditionalCodeRepositories": "",\n  "RootAccess": "",\n  "PlatformIdentifier": "",\n  "InstanceMetadataServiceConfiguration": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstance'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "NotebookInstanceName": "",
  "InstanceType": "",
  "SubnetId": "",
  "SecurityGroupIds": "",
  "RoleArn": "",
  "KmsKeyId": "",
  "Tags": "",
  "LifecycleConfigName": "",
  "DirectInternetAccess": "",
  "VolumeSizeInGB": "",
  "AcceleratorTypes": "",
  "DefaultCodeRepository": "",
  "AdditionalCodeRepositories": "",
  "RootAccess": "",
  "PlatformIdentifier": "",
  "InstanceMetadataServiceConfiguration": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstance")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstanceLifecycleConfig");

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  \"NotebookInstanceLifecycleConfigName\": \"\",\n  \"OnCreate\": \"\",\n  \"OnStart\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstanceLifecycleConfig" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:NotebookInstanceLifecycleConfigName ""
                                                                                                                        :OnCreate ""
                                                                                                                        :OnStart ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstanceLifecycleConfig"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"NotebookInstanceLifecycleConfigName\": \"\",\n  \"OnCreate\": \"\",\n  \"OnStart\": \"\"\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=SageMaker.CreateNotebookInstanceLifecycleConfig"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"NotebookInstanceLifecycleConfigName\": \"\",\n  \"OnCreate\": \"\",\n  \"OnStart\": \"\"\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=SageMaker.CreateNotebookInstanceLifecycleConfig");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"NotebookInstanceLifecycleConfigName\": \"\",\n  \"OnCreate\": \"\",\n  \"OnStart\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstanceLifecycleConfig"

	payload := strings.NewReader("{\n  \"NotebookInstanceLifecycleConfigName\": \"\",\n  \"OnCreate\": \"\",\n  \"OnStart\": \"\"\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

{
  "NotebookInstanceLifecycleConfigName": "",
  "OnCreate": "",
  "OnStart": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstanceLifecycleConfig")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"NotebookInstanceLifecycleConfigName\": \"\",\n  \"OnCreate\": \"\",\n  \"OnStart\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstanceLifecycleConfig"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"NotebookInstanceLifecycleConfigName\": \"\",\n  \"OnCreate\": \"\",\n  \"OnStart\": \"\"\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  \"NotebookInstanceLifecycleConfigName\": \"\",\n  \"OnCreate\": \"\",\n  \"OnStart\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstanceLifecycleConfig")
  .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=SageMaker.CreateNotebookInstanceLifecycleConfig")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"NotebookInstanceLifecycleConfigName\": \"\",\n  \"OnCreate\": \"\",\n  \"OnStart\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  NotebookInstanceLifecycleConfigName: '',
  OnCreate: '',
  OnStart: ''
});

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=SageMaker.CreateNotebookInstanceLifecycleConfig');
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=SageMaker.CreateNotebookInstanceLifecycleConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {NotebookInstanceLifecycleConfigName: '', OnCreate: '', OnStart: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstanceLifecycleConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"NotebookInstanceLifecycleConfigName":"","OnCreate":"","OnStart":""}'
};

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=SageMaker.CreateNotebookInstanceLifecycleConfig',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "NotebookInstanceLifecycleConfigName": "",\n  "OnCreate": "",\n  "OnStart": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"NotebookInstanceLifecycleConfigName\": \"\",\n  \"OnCreate\": \"\",\n  \"OnStart\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstanceLifecycleConfig")
  .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({NotebookInstanceLifecycleConfigName: '', OnCreate: '', OnStart: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstanceLifecycleConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {NotebookInstanceLifecycleConfigName: '', OnCreate: '', OnStart: ''},
  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=SageMaker.CreateNotebookInstanceLifecycleConfig');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  NotebookInstanceLifecycleConfigName: '',
  OnCreate: '',
  OnStart: ''
});

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=SageMaker.CreateNotebookInstanceLifecycleConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {NotebookInstanceLifecycleConfigName: '', OnCreate: '', OnStart: ''}
};

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=SageMaker.CreateNotebookInstanceLifecycleConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"NotebookInstanceLifecycleConfigName":"","OnCreate":"","OnStart":""}'
};

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 = @{ @"NotebookInstanceLifecycleConfigName": @"",
                              @"OnCreate": @"",
                              @"OnStart": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstanceLifecycleConfig"]
                                                       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=SageMaker.CreateNotebookInstanceLifecycleConfig" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"NotebookInstanceLifecycleConfigName\": \"\",\n  \"OnCreate\": \"\",\n  \"OnStart\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstanceLifecycleConfig",
  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([
    'NotebookInstanceLifecycleConfigName' => '',
    'OnCreate' => '',
    'OnStart' => ''
  ]),
  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=SageMaker.CreateNotebookInstanceLifecycleConfig', [
  'body' => '{
  "NotebookInstanceLifecycleConfigName": "",
  "OnCreate": "",
  "OnStart": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstanceLifecycleConfig');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'NotebookInstanceLifecycleConfigName' => '',
  'OnCreate' => '',
  'OnStart' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'NotebookInstanceLifecycleConfigName' => '',
  'OnCreate' => '',
  'OnStart' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstanceLifecycleConfig');
$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=SageMaker.CreateNotebookInstanceLifecycleConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "NotebookInstanceLifecycleConfigName": "",
  "OnCreate": "",
  "OnStart": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstanceLifecycleConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "NotebookInstanceLifecycleConfigName": "",
  "OnCreate": "",
  "OnStart": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"NotebookInstanceLifecycleConfigName\": \"\",\n  \"OnCreate\": \"\",\n  \"OnStart\": \"\"\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=SageMaker.CreateNotebookInstanceLifecycleConfig"

payload = {
    "NotebookInstanceLifecycleConfigName": "",
    "OnCreate": "",
    "OnStart": ""
}
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=SageMaker.CreateNotebookInstanceLifecycleConfig"

payload <- "{\n  \"NotebookInstanceLifecycleConfigName\": \"\",\n  \"OnCreate\": \"\",\n  \"OnStart\": \"\"\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=SageMaker.CreateNotebookInstanceLifecycleConfig")

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  \"NotebookInstanceLifecycleConfigName\": \"\",\n  \"OnCreate\": \"\",\n  \"OnStart\": \"\"\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  \"NotebookInstanceLifecycleConfigName\": \"\",\n  \"OnCreate\": \"\",\n  \"OnStart\": \"\"\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=SageMaker.CreateNotebookInstanceLifecycleConfig";

    let payload = json!({
        "NotebookInstanceLifecycleConfigName": "",
        "OnCreate": "",
        "OnStart": ""
    });

    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);
}

echo '{
  "NotebookInstanceLifecycleConfigName": "",
  "OnCreate": "",
  "OnStart": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstanceLifecycleConfig' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "NotebookInstanceLifecycleConfigName": "",\n  "OnCreate": "",\n  "OnStart": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstanceLifecycleConfig'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "NotebookInstanceLifecycleConfigName": "",
  "OnCreate": "",
  "OnStart": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateNotebookInstanceLifecycleConfig")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePipeline");

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  \"PipelineName\": \"\",\n  \"PipelineDisplayName\": \"\",\n  \"PipelineDefinition\": \"\",\n  \"PipelineDefinitionS3Location\": \"\",\n  \"PipelineDescription\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ParallelismConfiguration\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePipeline" {:headers {:x-amz-target ""}
                                                                                   :content-type :json
                                                                                   :form-params {:PipelineName ""
                                                                                                 :PipelineDisplayName ""
                                                                                                 :PipelineDefinition ""
                                                                                                 :PipelineDefinitionS3Location ""
                                                                                                 :PipelineDescription ""
                                                                                                 :ClientRequestToken ""
                                                                                                 :RoleArn ""
                                                                                                 :Tags ""
                                                                                                 :ParallelismConfiguration ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePipeline"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"PipelineName\": \"\",\n  \"PipelineDisplayName\": \"\",\n  \"PipelineDefinition\": \"\",\n  \"PipelineDefinitionS3Location\": \"\",\n  \"PipelineDescription\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ParallelismConfiguration\": \"\"\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=SageMaker.CreatePipeline"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"PipelineName\": \"\",\n  \"PipelineDisplayName\": \"\",\n  \"PipelineDefinition\": \"\",\n  \"PipelineDefinitionS3Location\": \"\",\n  \"PipelineDescription\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ParallelismConfiguration\": \"\"\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=SageMaker.CreatePipeline");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"PipelineName\": \"\",\n  \"PipelineDisplayName\": \"\",\n  \"PipelineDefinition\": \"\",\n  \"PipelineDefinitionS3Location\": \"\",\n  \"PipelineDescription\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ParallelismConfiguration\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePipeline"

	payload := strings.NewReader("{\n  \"PipelineName\": \"\",\n  \"PipelineDisplayName\": \"\",\n  \"PipelineDefinition\": \"\",\n  \"PipelineDefinitionS3Location\": \"\",\n  \"PipelineDescription\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ParallelismConfiguration\": \"\"\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: 241

{
  "PipelineName": "",
  "PipelineDisplayName": "",
  "PipelineDefinition": "",
  "PipelineDefinitionS3Location": "",
  "PipelineDescription": "",
  "ClientRequestToken": "",
  "RoleArn": "",
  "Tags": "",
  "ParallelismConfiguration": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePipeline")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"PipelineName\": \"\",\n  \"PipelineDisplayName\": \"\",\n  \"PipelineDefinition\": \"\",\n  \"PipelineDefinitionS3Location\": \"\",\n  \"PipelineDescription\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ParallelismConfiguration\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePipeline"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"PipelineName\": \"\",\n  \"PipelineDisplayName\": \"\",\n  \"PipelineDefinition\": \"\",\n  \"PipelineDefinitionS3Location\": \"\",\n  \"PipelineDescription\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ParallelismConfiguration\": \"\"\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  \"PipelineName\": \"\",\n  \"PipelineDisplayName\": \"\",\n  \"PipelineDefinition\": \"\",\n  \"PipelineDefinitionS3Location\": \"\",\n  \"PipelineDescription\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ParallelismConfiguration\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePipeline")
  .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=SageMaker.CreatePipeline")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"PipelineName\": \"\",\n  \"PipelineDisplayName\": \"\",\n  \"PipelineDefinition\": \"\",\n  \"PipelineDefinitionS3Location\": \"\",\n  \"PipelineDescription\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ParallelismConfiguration\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  PipelineName: '',
  PipelineDisplayName: '',
  PipelineDefinition: '',
  PipelineDefinitionS3Location: '',
  PipelineDescription: '',
  ClientRequestToken: '',
  RoleArn: '',
  Tags: '',
  ParallelismConfiguration: ''
});

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=SageMaker.CreatePipeline');
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=SageMaker.CreatePipeline',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    PipelineName: '',
    PipelineDisplayName: '',
    PipelineDefinition: '',
    PipelineDefinitionS3Location: '',
    PipelineDescription: '',
    ClientRequestToken: '',
    RoleArn: '',
    Tags: '',
    ParallelismConfiguration: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePipeline';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"PipelineName":"","PipelineDisplayName":"","PipelineDefinition":"","PipelineDefinitionS3Location":"","PipelineDescription":"","ClientRequestToken":"","RoleArn":"","Tags":"","ParallelismConfiguration":""}'
};

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=SageMaker.CreatePipeline',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "PipelineName": "",\n  "PipelineDisplayName": "",\n  "PipelineDefinition": "",\n  "PipelineDefinitionS3Location": "",\n  "PipelineDescription": "",\n  "ClientRequestToken": "",\n  "RoleArn": "",\n  "Tags": "",\n  "ParallelismConfiguration": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"PipelineName\": \"\",\n  \"PipelineDisplayName\": \"\",\n  \"PipelineDefinition\": \"\",\n  \"PipelineDefinitionS3Location\": \"\",\n  \"PipelineDescription\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ParallelismConfiguration\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePipeline")
  .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({
  PipelineName: '',
  PipelineDisplayName: '',
  PipelineDefinition: '',
  PipelineDefinitionS3Location: '',
  PipelineDescription: '',
  ClientRequestToken: '',
  RoleArn: '',
  Tags: '',
  ParallelismConfiguration: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePipeline',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    PipelineName: '',
    PipelineDisplayName: '',
    PipelineDefinition: '',
    PipelineDefinitionS3Location: '',
    PipelineDescription: '',
    ClientRequestToken: '',
    RoleArn: '',
    Tags: '',
    ParallelismConfiguration: ''
  },
  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=SageMaker.CreatePipeline');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  PipelineName: '',
  PipelineDisplayName: '',
  PipelineDefinition: '',
  PipelineDefinitionS3Location: '',
  PipelineDescription: '',
  ClientRequestToken: '',
  RoleArn: '',
  Tags: '',
  ParallelismConfiguration: ''
});

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=SageMaker.CreatePipeline',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    PipelineName: '',
    PipelineDisplayName: '',
    PipelineDefinition: '',
    PipelineDefinitionS3Location: '',
    PipelineDescription: '',
    ClientRequestToken: '',
    RoleArn: '',
    Tags: '',
    ParallelismConfiguration: ''
  }
};

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=SageMaker.CreatePipeline';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"PipelineName":"","PipelineDisplayName":"","PipelineDefinition":"","PipelineDefinitionS3Location":"","PipelineDescription":"","ClientRequestToken":"","RoleArn":"","Tags":"","ParallelismConfiguration":""}'
};

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 = @{ @"PipelineName": @"",
                              @"PipelineDisplayName": @"",
                              @"PipelineDefinition": @"",
                              @"PipelineDefinitionS3Location": @"",
                              @"PipelineDescription": @"",
                              @"ClientRequestToken": @"",
                              @"RoleArn": @"",
                              @"Tags": @"",
                              @"ParallelismConfiguration": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePipeline"]
                                                       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=SageMaker.CreatePipeline" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"PipelineName\": \"\",\n  \"PipelineDisplayName\": \"\",\n  \"PipelineDefinition\": \"\",\n  \"PipelineDefinitionS3Location\": \"\",\n  \"PipelineDescription\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ParallelismConfiguration\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePipeline",
  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([
    'PipelineName' => '',
    'PipelineDisplayName' => '',
    'PipelineDefinition' => '',
    'PipelineDefinitionS3Location' => '',
    'PipelineDescription' => '',
    'ClientRequestToken' => '',
    'RoleArn' => '',
    'Tags' => '',
    'ParallelismConfiguration' => ''
  ]),
  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=SageMaker.CreatePipeline', [
  'body' => '{
  "PipelineName": "",
  "PipelineDisplayName": "",
  "PipelineDefinition": "",
  "PipelineDefinitionS3Location": "",
  "PipelineDescription": "",
  "ClientRequestToken": "",
  "RoleArn": "",
  "Tags": "",
  "ParallelismConfiguration": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePipeline');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'PipelineName' => '',
  'PipelineDisplayName' => '',
  'PipelineDefinition' => '',
  'PipelineDefinitionS3Location' => '',
  'PipelineDescription' => '',
  'ClientRequestToken' => '',
  'RoleArn' => '',
  'Tags' => '',
  'ParallelismConfiguration' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'PipelineName' => '',
  'PipelineDisplayName' => '',
  'PipelineDefinition' => '',
  'PipelineDefinitionS3Location' => '',
  'PipelineDescription' => '',
  'ClientRequestToken' => '',
  'RoleArn' => '',
  'Tags' => '',
  'ParallelismConfiguration' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePipeline');
$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=SageMaker.CreatePipeline' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "PipelineName": "",
  "PipelineDisplayName": "",
  "PipelineDefinition": "",
  "PipelineDefinitionS3Location": "",
  "PipelineDescription": "",
  "ClientRequestToken": "",
  "RoleArn": "",
  "Tags": "",
  "ParallelismConfiguration": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePipeline' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "PipelineName": "",
  "PipelineDisplayName": "",
  "PipelineDefinition": "",
  "PipelineDefinitionS3Location": "",
  "PipelineDescription": "",
  "ClientRequestToken": "",
  "RoleArn": "",
  "Tags": "",
  "ParallelismConfiguration": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"PipelineName\": \"\",\n  \"PipelineDisplayName\": \"\",\n  \"PipelineDefinition\": \"\",\n  \"PipelineDefinitionS3Location\": \"\",\n  \"PipelineDescription\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ParallelismConfiguration\": \"\"\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=SageMaker.CreatePipeline"

payload = {
    "PipelineName": "",
    "PipelineDisplayName": "",
    "PipelineDefinition": "",
    "PipelineDefinitionS3Location": "",
    "PipelineDescription": "",
    "ClientRequestToken": "",
    "RoleArn": "",
    "Tags": "",
    "ParallelismConfiguration": ""
}
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=SageMaker.CreatePipeline"

payload <- "{\n  \"PipelineName\": \"\",\n  \"PipelineDisplayName\": \"\",\n  \"PipelineDefinition\": \"\",\n  \"PipelineDefinitionS3Location\": \"\",\n  \"PipelineDescription\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ParallelismConfiguration\": \"\"\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=SageMaker.CreatePipeline")

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  \"PipelineName\": \"\",\n  \"PipelineDisplayName\": \"\",\n  \"PipelineDefinition\": \"\",\n  \"PipelineDefinitionS3Location\": \"\",\n  \"PipelineDescription\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ParallelismConfiguration\": \"\"\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  \"PipelineName\": \"\",\n  \"PipelineDisplayName\": \"\",\n  \"PipelineDefinition\": \"\",\n  \"PipelineDefinitionS3Location\": \"\",\n  \"PipelineDescription\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ParallelismConfiguration\": \"\"\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=SageMaker.CreatePipeline";

    let payload = json!({
        "PipelineName": "",
        "PipelineDisplayName": "",
        "PipelineDefinition": "",
        "PipelineDefinitionS3Location": "",
        "PipelineDescription": "",
        "ClientRequestToken": "",
        "RoleArn": "",
        "Tags": "",
        "ParallelismConfiguration": ""
    });

    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);
}

echo '{
  "PipelineName": "",
  "PipelineDisplayName": "",
  "PipelineDefinition": "",
  "PipelineDefinitionS3Location": "",
  "PipelineDescription": "",
  "ClientRequestToken": "",
  "RoleArn": "",
  "Tags": "",
  "ParallelismConfiguration": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePipeline' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "PipelineName": "",\n  "PipelineDisplayName": "",\n  "PipelineDefinition": "",\n  "PipelineDefinitionS3Location": "",\n  "PipelineDescription": "",\n  "ClientRequestToken": "",\n  "RoleArn": "",\n  "Tags": "",\n  "ParallelismConfiguration": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePipeline'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "PipelineName": "",
  "PipelineDisplayName": "",
  "PipelineDefinition": "",
  "PipelineDefinitionS3Location": "",
  "PipelineDescription": "",
  "ClientRequestToken": "",
  "RoleArn": "",
  "Tags": "",
  "ParallelismConfiguration": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePipeline")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedDomainUrl");

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  \"DomainId\": \"\",\n  \"UserProfileName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\",\n  \"ExpiresInSeconds\": \"\",\n  \"SpaceName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedDomainUrl" {:headers {:x-amz-target ""}
                                                                                             :content-type :json
                                                                                             :form-params {:DomainId ""
                                                                                                           :UserProfileName ""
                                                                                                           :SessionExpirationDurationInSeconds ""
                                                                                                           :ExpiresInSeconds ""
                                                                                                           :SpaceName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedDomainUrl"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"DomainId\": \"\",\n  \"UserProfileName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\",\n  \"ExpiresInSeconds\": \"\",\n  \"SpaceName\": \"\"\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=SageMaker.CreatePresignedDomainUrl"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"DomainId\": \"\",\n  \"UserProfileName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\",\n  \"ExpiresInSeconds\": \"\",\n  \"SpaceName\": \"\"\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=SageMaker.CreatePresignedDomainUrl");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DomainId\": \"\",\n  \"UserProfileName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\",\n  \"ExpiresInSeconds\": \"\",\n  \"SpaceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedDomainUrl"

	payload := strings.NewReader("{\n  \"DomainId\": \"\",\n  \"UserProfileName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\",\n  \"ExpiresInSeconds\": \"\",\n  \"SpaceName\": \"\"\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: 134

{
  "DomainId": "",
  "UserProfileName": "",
  "SessionExpirationDurationInSeconds": "",
  "ExpiresInSeconds": "",
  "SpaceName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedDomainUrl")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DomainId\": \"\",\n  \"UserProfileName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\",\n  \"ExpiresInSeconds\": \"\",\n  \"SpaceName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedDomainUrl"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"DomainId\": \"\",\n  \"UserProfileName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\",\n  \"ExpiresInSeconds\": \"\",\n  \"SpaceName\": \"\"\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  \"DomainId\": \"\",\n  \"UserProfileName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\",\n  \"ExpiresInSeconds\": \"\",\n  \"SpaceName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedDomainUrl")
  .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=SageMaker.CreatePresignedDomainUrl")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"DomainId\": \"\",\n  \"UserProfileName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\",\n  \"ExpiresInSeconds\": \"\",\n  \"SpaceName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  DomainId: '',
  UserProfileName: '',
  SessionExpirationDurationInSeconds: '',
  ExpiresInSeconds: '',
  SpaceName: ''
});

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=SageMaker.CreatePresignedDomainUrl');
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=SageMaker.CreatePresignedDomainUrl',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    DomainId: '',
    UserProfileName: '',
    SessionExpirationDurationInSeconds: '',
    ExpiresInSeconds: '',
    SpaceName: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedDomainUrl';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DomainId":"","UserProfileName":"","SessionExpirationDurationInSeconds":"","ExpiresInSeconds":"","SpaceName":""}'
};

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=SageMaker.CreatePresignedDomainUrl',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DomainId": "",\n  "UserProfileName": "",\n  "SessionExpirationDurationInSeconds": "",\n  "ExpiresInSeconds": "",\n  "SpaceName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DomainId\": \"\",\n  \"UserProfileName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\",\n  \"ExpiresInSeconds\": \"\",\n  \"SpaceName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedDomainUrl")
  .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({
  DomainId: '',
  UserProfileName: '',
  SessionExpirationDurationInSeconds: '',
  ExpiresInSeconds: '',
  SpaceName: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedDomainUrl',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    DomainId: '',
    UserProfileName: '',
    SessionExpirationDurationInSeconds: '',
    ExpiresInSeconds: '',
    SpaceName: ''
  },
  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=SageMaker.CreatePresignedDomainUrl');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  DomainId: '',
  UserProfileName: '',
  SessionExpirationDurationInSeconds: '',
  ExpiresInSeconds: '',
  SpaceName: ''
});

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=SageMaker.CreatePresignedDomainUrl',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    DomainId: '',
    UserProfileName: '',
    SessionExpirationDurationInSeconds: '',
    ExpiresInSeconds: '',
    SpaceName: ''
  }
};

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=SageMaker.CreatePresignedDomainUrl';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DomainId":"","UserProfileName":"","SessionExpirationDurationInSeconds":"","ExpiresInSeconds":"","SpaceName":""}'
};

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 = @{ @"DomainId": @"",
                              @"UserProfileName": @"",
                              @"SessionExpirationDurationInSeconds": @"",
                              @"ExpiresInSeconds": @"",
                              @"SpaceName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedDomainUrl"]
                                                       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=SageMaker.CreatePresignedDomainUrl" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"DomainId\": \"\",\n  \"UserProfileName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\",\n  \"ExpiresInSeconds\": \"\",\n  \"SpaceName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedDomainUrl",
  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([
    'DomainId' => '',
    'UserProfileName' => '',
    'SessionExpirationDurationInSeconds' => '',
    'ExpiresInSeconds' => '',
    'SpaceName' => ''
  ]),
  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=SageMaker.CreatePresignedDomainUrl', [
  'body' => '{
  "DomainId": "",
  "UserProfileName": "",
  "SessionExpirationDurationInSeconds": "",
  "ExpiresInSeconds": "",
  "SpaceName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedDomainUrl');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DomainId' => '',
  'UserProfileName' => '',
  'SessionExpirationDurationInSeconds' => '',
  'ExpiresInSeconds' => '',
  'SpaceName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'DomainId' => '',
  'UserProfileName' => '',
  'SessionExpirationDurationInSeconds' => '',
  'ExpiresInSeconds' => '',
  'SpaceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedDomainUrl');
$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=SageMaker.CreatePresignedDomainUrl' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DomainId": "",
  "UserProfileName": "",
  "SessionExpirationDurationInSeconds": "",
  "ExpiresInSeconds": "",
  "SpaceName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedDomainUrl' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DomainId": "",
  "UserProfileName": "",
  "SessionExpirationDurationInSeconds": "",
  "ExpiresInSeconds": "",
  "SpaceName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"DomainId\": \"\",\n  \"UserProfileName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\",\n  \"ExpiresInSeconds\": \"\",\n  \"SpaceName\": \"\"\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=SageMaker.CreatePresignedDomainUrl"

payload = {
    "DomainId": "",
    "UserProfileName": "",
    "SessionExpirationDurationInSeconds": "",
    "ExpiresInSeconds": "",
    "SpaceName": ""
}
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=SageMaker.CreatePresignedDomainUrl"

payload <- "{\n  \"DomainId\": \"\",\n  \"UserProfileName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\",\n  \"ExpiresInSeconds\": \"\",\n  \"SpaceName\": \"\"\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=SageMaker.CreatePresignedDomainUrl")

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  \"DomainId\": \"\",\n  \"UserProfileName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\",\n  \"ExpiresInSeconds\": \"\",\n  \"SpaceName\": \"\"\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  \"DomainId\": \"\",\n  \"UserProfileName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\",\n  \"ExpiresInSeconds\": \"\",\n  \"SpaceName\": \"\"\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=SageMaker.CreatePresignedDomainUrl";

    let payload = json!({
        "DomainId": "",
        "UserProfileName": "",
        "SessionExpirationDurationInSeconds": "",
        "ExpiresInSeconds": "",
        "SpaceName": ""
    });

    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);
}

echo '{
  "DomainId": "",
  "UserProfileName": "",
  "SessionExpirationDurationInSeconds": "",
  "ExpiresInSeconds": "",
  "SpaceName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedDomainUrl' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "DomainId": "",\n  "UserProfileName": "",\n  "SessionExpirationDurationInSeconds": "",\n  "ExpiresInSeconds": "",\n  "SpaceName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedDomainUrl'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "DomainId": "",
  "UserProfileName": "",
  "SessionExpirationDurationInSeconds": "",
  "ExpiresInSeconds": "",
  "SpaceName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedDomainUrl")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedNotebookInstanceUrl");

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  \"NotebookInstanceName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedNotebookInstanceUrl" {:headers {:x-amz-target ""}
                                                                                                       :content-type :json
                                                                                                       :form-params {:NotebookInstanceName ""
                                                                                                                     :SessionExpirationDurationInSeconds ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedNotebookInstanceUrl"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"NotebookInstanceName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\"\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=SageMaker.CreatePresignedNotebookInstanceUrl"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"NotebookInstanceName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\"\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=SageMaker.CreatePresignedNotebookInstanceUrl");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"NotebookInstanceName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedNotebookInstanceUrl"

	payload := strings.NewReader("{\n  \"NotebookInstanceName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\"\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: 76

{
  "NotebookInstanceName": "",
  "SessionExpirationDurationInSeconds": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedNotebookInstanceUrl")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"NotebookInstanceName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedNotebookInstanceUrl"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"NotebookInstanceName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\"\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  \"NotebookInstanceName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedNotebookInstanceUrl")
  .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=SageMaker.CreatePresignedNotebookInstanceUrl")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"NotebookInstanceName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  NotebookInstanceName: '',
  SessionExpirationDurationInSeconds: ''
});

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=SageMaker.CreatePresignedNotebookInstanceUrl');
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=SageMaker.CreatePresignedNotebookInstanceUrl',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {NotebookInstanceName: '', SessionExpirationDurationInSeconds: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedNotebookInstanceUrl';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"NotebookInstanceName":"","SessionExpirationDurationInSeconds":""}'
};

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=SageMaker.CreatePresignedNotebookInstanceUrl',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "NotebookInstanceName": "",\n  "SessionExpirationDurationInSeconds": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"NotebookInstanceName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedNotebookInstanceUrl")
  .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({NotebookInstanceName: '', SessionExpirationDurationInSeconds: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedNotebookInstanceUrl',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {NotebookInstanceName: '', SessionExpirationDurationInSeconds: ''},
  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=SageMaker.CreatePresignedNotebookInstanceUrl');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  NotebookInstanceName: '',
  SessionExpirationDurationInSeconds: ''
});

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=SageMaker.CreatePresignedNotebookInstanceUrl',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {NotebookInstanceName: '', SessionExpirationDurationInSeconds: ''}
};

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=SageMaker.CreatePresignedNotebookInstanceUrl';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"NotebookInstanceName":"","SessionExpirationDurationInSeconds":""}'
};

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 = @{ @"NotebookInstanceName": @"",
                              @"SessionExpirationDurationInSeconds": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedNotebookInstanceUrl"]
                                                       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=SageMaker.CreatePresignedNotebookInstanceUrl" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"NotebookInstanceName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedNotebookInstanceUrl",
  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([
    'NotebookInstanceName' => '',
    'SessionExpirationDurationInSeconds' => ''
  ]),
  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=SageMaker.CreatePresignedNotebookInstanceUrl', [
  'body' => '{
  "NotebookInstanceName": "",
  "SessionExpirationDurationInSeconds": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedNotebookInstanceUrl');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'NotebookInstanceName' => '',
  'SessionExpirationDurationInSeconds' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'NotebookInstanceName' => '',
  'SessionExpirationDurationInSeconds' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedNotebookInstanceUrl');
$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=SageMaker.CreatePresignedNotebookInstanceUrl' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "NotebookInstanceName": "",
  "SessionExpirationDurationInSeconds": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedNotebookInstanceUrl' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "NotebookInstanceName": "",
  "SessionExpirationDurationInSeconds": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"NotebookInstanceName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\"\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=SageMaker.CreatePresignedNotebookInstanceUrl"

payload = {
    "NotebookInstanceName": "",
    "SessionExpirationDurationInSeconds": ""
}
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=SageMaker.CreatePresignedNotebookInstanceUrl"

payload <- "{\n  \"NotebookInstanceName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\"\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=SageMaker.CreatePresignedNotebookInstanceUrl")

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  \"NotebookInstanceName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\"\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  \"NotebookInstanceName\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\"\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=SageMaker.CreatePresignedNotebookInstanceUrl";

    let payload = json!({
        "NotebookInstanceName": "",
        "SessionExpirationDurationInSeconds": ""
    });

    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);
}

echo '{
  "NotebookInstanceName": "",
  "SessionExpirationDurationInSeconds": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedNotebookInstanceUrl' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "NotebookInstanceName": "",\n  "SessionExpirationDurationInSeconds": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedNotebookInstanceUrl'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "NotebookInstanceName": "",
  "SessionExpirationDurationInSeconds": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SageMaker.CreatePresignedNotebookInstanceUrl")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProcessingJob");

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  \"ProcessingInputs\": \"\",\n  \"ProcessingOutputConfig\": \"\",\n  \"ProcessingJobName\": \"\",\n  \"ProcessingResources\": \"\",\n  \"StoppingCondition\": \"\",\n  \"AppSpecification\": \"\",\n  \"Environment\": \"\",\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProcessingJob" {:headers {:x-amz-target ""}
                                                                                        :content-type :json
                                                                                        :form-params {:ProcessingInputs ""
                                                                                                      :ProcessingOutputConfig ""
                                                                                                      :ProcessingJobName ""
                                                                                                      :ProcessingResources ""
                                                                                                      :StoppingCondition ""
                                                                                                      :AppSpecification ""
                                                                                                      :Environment ""
                                                                                                      :NetworkConfig ""
                                                                                                      :RoleArn ""
                                                                                                      :Tags ""
                                                                                                      :ExperimentConfig {:ExperimentName ""
                                                                                                                         :TrialName ""
                                                                                                                         :TrialComponentDisplayName ""
                                                                                                                         :RunName ""}}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProcessingJob"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ProcessingInputs\": \"\",\n  \"ProcessingOutputConfig\": \"\",\n  \"ProcessingJobName\": \"\",\n  \"ProcessingResources\": \"\",\n  \"StoppingCondition\": \"\",\n  \"AppSpecification\": \"\",\n  \"Environment\": \"\",\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  }\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=SageMaker.CreateProcessingJob"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ProcessingInputs\": \"\",\n  \"ProcessingOutputConfig\": \"\",\n  \"ProcessingJobName\": \"\",\n  \"ProcessingResources\": \"\",\n  \"StoppingCondition\": \"\",\n  \"AppSpecification\": \"\",\n  \"Environment\": \"\",\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  }\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=SageMaker.CreateProcessingJob");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ProcessingInputs\": \"\",\n  \"ProcessingOutputConfig\": \"\",\n  \"ProcessingJobName\": \"\",\n  \"ProcessingResources\": \"\",\n  \"StoppingCondition\": \"\",\n  \"AppSpecification\": \"\",\n  \"Environment\": \"\",\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProcessingJob"

	payload := strings.NewReader("{\n  \"ProcessingInputs\": \"\",\n  \"ProcessingOutputConfig\": \"\",\n  \"ProcessingJobName\": \"\",\n  \"ProcessingResources\": \"\",\n  \"StoppingCondition\": \"\",\n  \"AppSpecification\": \"\",\n  \"Environment\": \"\",\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  }\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: 375

{
  "ProcessingInputs": "",
  "ProcessingOutputConfig": "",
  "ProcessingJobName": "",
  "ProcessingResources": "",
  "StoppingCondition": "",
  "AppSpecification": "",
  "Environment": "",
  "NetworkConfig": "",
  "RoleArn": "",
  "Tags": "",
  "ExperimentConfig": {
    "ExperimentName": "",
    "TrialName": "",
    "TrialComponentDisplayName": "",
    "RunName": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProcessingJob")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ProcessingInputs\": \"\",\n  \"ProcessingOutputConfig\": \"\",\n  \"ProcessingJobName\": \"\",\n  \"ProcessingResources\": \"\",\n  \"StoppingCondition\": \"\",\n  \"AppSpecification\": \"\",\n  \"Environment\": \"\",\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProcessingJob"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ProcessingInputs\": \"\",\n  \"ProcessingOutputConfig\": \"\",\n  \"ProcessingJobName\": \"\",\n  \"ProcessingResources\": \"\",\n  \"StoppingCondition\": \"\",\n  \"AppSpecification\": \"\",\n  \"Environment\": \"\",\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  }\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  \"ProcessingInputs\": \"\",\n  \"ProcessingOutputConfig\": \"\",\n  \"ProcessingJobName\": \"\",\n  \"ProcessingResources\": \"\",\n  \"StoppingCondition\": \"\",\n  \"AppSpecification\": \"\",\n  \"Environment\": \"\",\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProcessingJob")
  .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=SageMaker.CreateProcessingJob")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ProcessingInputs\": \"\",\n  \"ProcessingOutputConfig\": \"\",\n  \"ProcessingJobName\": \"\",\n  \"ProcessingResources\": \"\",\n  \"StoppingCondition\": \"\",\n  \"AppSpecification\": \"\",\n  \"Environment\": \"\",\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  ProcessingInputs: '',
  ProcessingOutputConfig: '',
  ProcessingJobName: '',
  ProcessingResources: '',
  StoppingCondition: '',
  AppSpecification: '',
  Environment: '',
  NetworkConfig: '',
  RoleArn: '',
  Tags: '',
  ExperimentConfig: {
    ExperimentName: '',
    TrialName: '',
    TrialComponentDisplayName: '',
    RunName: ''
  }
});

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=SageMaker.CreateProcessingJob');
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=SageMaker.CreateProcessingJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ProcessingInputs: '',
    ProcessingOutputConfig: '',
    ProcessingJobName: '',
    ProcessingResources: '',
    StoppingCondition: '',
    AppSpecification: '',
    Environment: '',
    NetworkConfig: '',
    RoleArn: '',
    Tags: '',
    ExperimentConfig: {ExperimentName: '', TrialName: '', TrialComponentDisplayName: '', RunName: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProcessingJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ProcessingInputs":"","ProcessingOutputConfig":"","ProcessingJobName":"","ProcessingResources":"","StoppingCondition":"","AppSpecification":"","Environment":"","NetworkConfig":"","RoleArn":"","Tags":"","ExperimentConfig":{"ExperimentName":"","TrialName":"","TrialComponentDisplayName":"","RunName":""}}'
};

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=SageMaker.CreateProcessingJob',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ProcessingInputs": "",\n  "ProcessingOutputConfig": "",\n  "ProcessingJobName": "",\n  "ProcessingResources": "",\n  "StoppingCondition": "",\n  "AppSpecification": "",\n  "Environment": "",\n  "NetworkConfig": "",\n  "RoleArn": "",\n  "Tags": "",\n  "ExperimentConfig": {\n    "ExperimentName": "",\n    "TrialName": "",\n    "TrialComponentDisplayName": "",\n    "RunName": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ProcessingInputs\": \"\",\n  \"ProcessingOutputConfig\": \"\",\n  \"ProcessingJobName\": \"\",\n  \"ProcessingResources\": \"\",\n  \"StoppingCondition\": \"\",\n  \"AppSpecification\": \"\",\n  \"Environment\": \"\",\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProcessingJob")
  .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({
  ProcessingInputs: '',
  ProcessingOutputConfig: '',
  ProcessingJobName: '',
  ProcessingResources: '',
  StoppingCondition: '',
  AppSpecification: '',
  Environment: '',
  NetworkConfig: '',
  RoleArn: '',
  Tags: '',
  ExperimentConfig: {ExperimentName: '', TrialName: '', TrialComponentDisplayName: '', RunName: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProcessingJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ProcessingInputs: '',
    ProcessingOutputConfig: '',
    ProcessingJobName: '',
    ProcessingResources: '',
    StoppingCondition: '',
    AppSpecification: '',
    Environment: '',
    NetworkConfig: '',
    RoleArn: '',
    Tags: '',
    ExperimentConfig: {ExperimentName: '', TrialName: '', TrialComponentDisplayName: '', RunName: ''}
  },
  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=SageMaker.CreateProcessingJob');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ProcessingInputs: '',
  ProcessingOutputConfig: '',
  ProcessingJobName: '',
  ProcessingResources: '',
  StoppingCondition: '',
  AppSpecification: '',
  Environment: '',
  NetworkConfig: '',
  RoleArn: '',
  Tags: '',
  ExperimentConfig: {
    ExperimentName: '',
    TrialName: '',
    TrialComponentDisplayName: '',
    RunName: ''
  }
});

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=SageMaker.CreateProcessingJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ProcessingInputs: '',
    ProcessingOutputConfig: '',
    ProcessingJobName: '',
    ProcessingResources: '',
    StoppingCondition: '',
    AppSpecification: '',
    Environment: '',
    NetworkConfig: '',
    RoleArn: '',
    Tags: '',
    ExperimentConfig: {ExperimentName: '', TrialName: '', TrialComponentDisplayName: '', RunName: ''}
  }
};

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=SageMaker.CreateProcessingJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ProcessingInputs":"","ProcessingOutputConfig":"","ProcessingJobName":"","ProcessingResources":"","StoppingCondition":"","AppSpecification":"","Environment":"","NetworkConfig":"","RoleArn":"","Tags":"","ExperimentConfig":{"ExperimentName":"","TrialName":"","TrialComponentDisplayName":"","RunName":""}}'
};

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 = @{ @"ProcessingInputs": @"",
                              @"ProcessingOutputConfig": @"",
                              @"ProcessingJobName": @"",
                              @"ProcessingResources": @"",
                              @"StoppingCondition": @"",
                              @"AppSpecification": @"",
                              @"Environment": @"",
                              @"NetworkConfig": @"",
                              @"RoleArn": @"",
                              @"Tags": @"",
                              @"ExperimentConfig": @{ @"ExperimentName": @"", @"TrialName": @"", @"TrialComponentDisplayName": @"", @"RunName": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProcessingJob"]
                                                       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=SageMaker.CreateProcessingJob" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ProcessingInputs\": \"\",\n  \"ProcessingOutputConfig\": \"\",\n  \"ProcessingJobName\": \"\",\n  \"ProcessingResources\": \"\",\n  \"StoppingCondition\": \"\",\n  \"AppSpecification\": \"\",\n  \"Environment\": \"\",\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProcessingJob",
  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([
    'ProcessingInputs' => '',
    'ProcessingOutputConfig' => '',
    'ProcessingJobName' => '',
    'ProcessingResources' => '',
    'StoppingCondition' => '',
    'AppSpecification' => '',
    'Environment' => '',
    'NetworkConfig' => '',
    'RoleArn' => '',
    'Tags' => '',
    'ExperimentConfig' => [
        'ExperimentName' => '',
        'TrialName' => '',
        'TrialComponentDisplayName' => '',
        'RunName' => ''
    ]
  ]),
  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=SageMaker.CreateProcessingJob', [
  'body' => '{
  "ProcessingInputs": "",
  "ProcessingOutputConfig": "",
  "ProcessingJobName": "",
  "ProcessingResources": "",
  "StoppingCondition": "",
  "AppSpecification": "",
  "Environment": "",
  "NetworkConfig": "",
  "RoleArn": "",
  "Tags": "",
  "ExperimentConfig": {
    "ExperimentName": "",
    "TrialName": "",
    "TrialComponentDisplayName": "",
    "RunName": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProcessingJob');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ProcessingInputs' => '',
  'ProcessingOutputConfig' => '',
  'ProcessingJobName' => '',
  'ProcessingResources' => '',
  'StoppingCondition' => '',
  'AppSpecification' => '',
  'Environment' => '',
  'NetworkConfig' => '',
  'RoleArn' => '',
  'Tags' => '',
  'ExperimentConfig' => [
    'ExperimentName' => '',
    'TrialName' => '',
    'TrialComponentDisplayName' => '',
    'RunName' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ProcessingInputs' => '',
  'ProcessingOutputConfig' => '',
  'ProcessingJobName' => '',
  'ProcessingResources' => '',
  'StoppingCondition' => '',
  'AppSpecification' => '',
  'Environment' => '',
  'NetworkConfig' => '',
  'RoleArn' => '',
  'Tags' => '',
  'ExperimentConfig' => [
    'ExperimentName' => '',
    'TrialName' => '',
    'TrialComponentDisplayName' => '',
    'RunName' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProcessingJob');
$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=SageMaker.CreateProcessingJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ProcessingInputs": "",
  "ProcessingOutputConfig": "",
  "ProcessingJobName": "",
  "ProcessingResources": "",
  "StoppingCondition": "",
  "AppSpecification": "",
  "Environment": "",
  "NetworkConfig": "",
  "RoleArn": "",
  "Tags": "",
  "ExperimentConfig": {
    "ExperimentName": "",
    "TrialName": "",
    "TrialComponentDisplayName": "",
    "RunName": ""
  }
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProcessingJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ProcessingInputs": "",
  "ProcessingOutputConfig": "",
  "ProcessingJobName": "",
  "ProcessingResources": "",
  "StoppingCondition": "",
  "AppSpecification": "",
  "Environment": "",
  "NetworkConfig": "",
  "RoleArn": "",
  "Tags": "",
  "ExperimentConfig": {
    "ExperimentName": "",
    "TrialName": "",
    "TrialComponentDisplayName": "",
    "RunName": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ProcessingInputs\": \"\",\n  \"ProcessingOutputConfig\": \"\",\n  \"ProcessingJobName\": \"\",\n  \"ProcessingResources\": \"\",\n  \"StoppingCondition\": \"\",\n  \"AppSpecification\": \"\",\n  \"Environment\": \"\",\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  }\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=SageMaker.CreateProcessingJob"

payload = {
    "ProcessingInputs": "",
    "ProcessingOutputConfig": "",
    "ProcessingJobName": "",
    "ProcessingResources": "",
    "StoppingCondition": "",
    "AppSpecification": "",
    "Environment": "",
    "NetworkConfig": "",
    "RoleArn": "",
    "Tags": "",
    "ExperimentConfig": {
        "ExperimentName": "",
        "TrialName": "",
        "TrialComponentDisplayName": "",
        "RunName": ""
    }
}
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=SageMaker.CreateProcessingJob"

payload <- "{\n  \"ProcessingInputs\": \"\",\n  \"ProcessingOutputConfig\": \"\",\n  \"ProcessingJobName\": \"\",\n  \"ProcessingResources\": \"\",\n  \"StoppingCondition\": \"\",\n  \"AppSpecification\": \"\",\n  \"Environment\": \"\",\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  }\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=SageMaker.CreateProcessingJob")

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  \"ProcessingInputs\": \"\",\n  \"ProcessingOutputConfig\": \"\",\n  \"ProcessingJobName\": \"\",\n  \"ProcessingResources\": \"\",\n  \"StoppingCondition\": \"\",\n  \"AppSpecification\": \"\",\n  \"Environment\": \"\",\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  }\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  \"ProcessingInputs\": \"\",\n  \"ProcessingOutputConfig\": \"\",\n  \"ProcessingJobName\": \"\",\n  \"ProcessingResources\": \"\",\n  \"StoppingCondition\": \"\",\n  \"AppSpecification\": \"\",\n  \"Environment\": \"\",\n  \"NetworkConfig\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": \"\",\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  }\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=SageMaker.CreateProcessingJob";

    let payload = json!({
        "ProcessingInputs": "",
        "ProcessingOutputConfig": "",
        "ProcessingJobName": "",
        "ProcessingResources": "",
        "StoppingCondition": "",
        "AppSpecification": "",
        "Environment": "",
        "NetworkConfig": "",
        "RoleArn": "",
        "Tags": "",
        "ExperimentConfig": json!({
            "ExperimentName": "",
            "TrialName": "",
            "TrialComponentDisplayName": "",
            "RunName": ""
        })
    });

    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);
}

echo '{
  "ProcessingInputs": "",
  "ProcessingOutputConfig": "",
  "ProcessingJobName": "",
  "ProcessingResources": "",
  "StoppingCondition": "",
  "AppSpecification": "",
  "Environment": "",
  "NetworkConfig": "",
  "RoleArn": "",
  "Tags": "",
  "ExperimentConfig": {
    "ExperimentName": "",
    "TrialName": "",
    "TrialComponentDisplayName": "",
    "RunName": ""
  }
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProcessingJob' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ProcessingInputs": "",\n  "ProcessingOutputConfig": "",\n  "ProcessingJobName": "",\n  "ProcessingResources": "",\n  "StoppingCondition": "",\n  "AppSpecification": "",\n  "Environment": "",\n  "NetworkConfig": "",\n  "RoleArn": "",\n  "Tags": "",\n  "ExperimentConfig": {\n    "ExperimentName": "",\n    "TrialName": "",\n    "TrialComponentDisplayName": "",\n    "RunName": ""\n  }\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProcessingJob'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ProcessingInputs": "",
  "ProcessingOutputConfig": "",
  "ProcessingJobName": "",
  "ProcessingResources": "",
  "StoppingCondition": "",
  "AppSpecification": "",
  "Environment": "",
  "NetworkConfig": "",
  "RoleArn": "",
  "Tags": "",
  "ExperimentConfig": [
    "ExperimentName": "",
    "TrialName": "",
    "TrialComponentDisplayName": "",
    "RunName": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProcessingJob")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProject");

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  \"ProjectName\": \"\",\n  \"ProjectDescription\": \"\",\n  \"ServiceCatalogProvisioningDetails\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProject" {:headers {:x-amz-target ""}
                                                                                  :content-type :json
                                                                                  :form-params {:ProjectName ""
                                                                                                :ProjectDescription ""
                                                                                                :ServiceCatalogProvisioningDetails ""
                                                                                                :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProject"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ProjectName\": \"\",\n  \"ProjectDescription\": \"\",\n  \"ServiceCatalogProvisioningDetails\": \"\",\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=SageMaker.CreateProject"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ProjectName\": \"\",\n  \"ProjectDescription\": \"\",\n  \"ServiceCatalogProvisioningDetails\": \"\",\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=SageMaker.CreateProject");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ProjectName\": \"\",\n  \"ProjectDescription\": \"\",\n  \"ServiceCatalogProvisioningDetails\": \"\",\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=SageMaker.CreateProject"

	payload := strings.NewReader("{\n  \"ProjectName\": \"\",\n  \"ProjectDescription\": \"\",\n  \"ServiceCatalogProvisioningDetails\": \"\",\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: 108

{
  "ProjectName": "",
  "ProjectDescription": "",
  "ServiceCatalogProvisioningDetails": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProject")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ProjectName\": \"\",\n  \"ProjectDescription\": \"\",\n  \"ServiceCatalogProvisioningDetails\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProject"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ProjectName\": \"\",\n  \"ProjectDescription\": \"\",\n  \"ServiceCatalogProvisioningDetails\": \"\",\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  \"ProjectName\": \"\",\n  \"ProjectDescription\": \"\",\n  \"ServiceCatalogProvisioningDetails\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProject")
  .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=SageMaker.CreateProject")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ProjectName\": \"\",\n  \"ProjectDescription\": \"\",\n  \"ServiceCatalogProvisioningDetails\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ProjectName: '',
  ProjectDescription: '',
  ServiceCatalogProvisioningDetails: '',
  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=SageMaker.CreateProject');
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=SageMaker.CreateProject',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ProjectName: '',
    ProjectDescription: '',
    ServiceCatalogProvisioningDetails: '',
    Tags: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProject';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ProjectName":"","ProjectDescription":"","ServiceCatalogProvisioningDetails":"","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=SageMaker.CreateProject',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ProjectName": "",\n  "ProjectDescription": "",\n  "ServiceCatalogProvisioningDetails": "",\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  \"ProjectName\": \"\",\n  \"ProjectDescription\": \"\",\n  \"ServiceCatalogProvisioningDetails\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProject")
  .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({
  ProjectName: '',
  ProjectDescription: '',
  ServiceCatalogProvisioningDetails: '',
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProject',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ProjectName: '',
    ProjectDescription: '',
    ServiceCatalogProvisioningDetails: '',
    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=SageMaker.CreateProject');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ProjectName: '',
  ProjectDescription: '',
  ServiceCatalogProvisioningDetails: '',
  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=SageMaker.CreateProject',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ProjectName: '',
    ProjectDescription: '',
    ServiceCatalogProvisioningDetails: '',
    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=SageMaker.CreateProject';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ProjectName":"","ProjectDescription":"","ServiceCatalogProvisioningDetails":"","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 = @{ @"ProjectName": @"",
                              @"ProjectDescription": @"",
                              @"ServiceCatalogProvisioningDetails": @"",
                              @"Tags": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProject"]
                                                       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=SageMaker.CreateProject" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ProjectName\": \"\",\n  \"ProjectDescription\": \"\",\n  \"ServiceCatalogProvisioningDetails\": \"\",\n  \"Tags\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProject",
  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([
    'ProjectName' => '',
    'ProjectDescription' => '',
    'ServiceCatalogProvisioningDetails' => '',
    '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=SageMaker.CreateProject', [
  'body' => '{
  "ProjectName": "",
  "ProjectDescription": "",
  "ServiceCatalogProvisioningDetails": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProject');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ProjectName' => '',
  'ProjectDescription' => '',
  'ServiceCatalogProvisioningDetails' => '',
  'Tags' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ProjectName' => '',
  'ProjectDescription' => '',
  'ServiceCatalogProvisioningDetails' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProject');
$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=SageMaker.CreateProject' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ProjectName": "",
  "ProjectDescription": "",
  "ServiceCatalogProvisioningDetails": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProject' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ProjectName": "",
  "ProjectDescription": "",
  "ServiceCatalogProvisioningDetails": "",
  "Tags": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ProjectName\": \"\",\n  \"ProjectDescription\": \"\",\n  \"ServiceCatalogProvisioningDetails\": \"\",\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=SageMaker.CreateProject"

payload = {
    "ProjectName": "",
    "ProjectDescription": "",
    "ServiceCatalogProvisioningDetails": "",
    "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=SageMaker.CreateProject"

payload <- "{\n  \"ProjectName\": \"\",\n  \"ProjectDescription\": \"\",\n  \"ServiceCatalogProvisioningDetails\": \"\",\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=SageMaker.CreateProject")

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  \"ProjectName\": \"\",\n  \"ProjectDescription\": \"\",\n  \"ServiceCatalogProvisioningDetails\": \"\",\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  \"ProjectName\": \"\",\n  \"ProjectDescription\": \"\",\n  \"ServiceCatalogProvisioningDetails\": \"\",\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=SageMaker.CreateProject";

    let payload = json!({
        "ProjectName": "",
        "ProjectDescription": "",
        "ServiceCatalogProvisioningDetails": "",
        "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);
}

echo '{
  "ProjectName": "",
  "ProjectDescription": "",
  "ServiceCatalogProvisioningDetails": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProject' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ProjectName": "",\n  "ProjectDescription": "",\n  "ServiceCatalogProvisioningDetails": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProject'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ProjectName": "",
  "ProjectDescription": "",
  "ServiceCatalogProvisioningDetails": "",
  "Tags": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateProject")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateSpace");

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  \"DomainId\": \"\",\n  \"SpaceName\": \"\",\n  \"Tags\": \"\",\n  \"SpaceSettings\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateSpace" {:headers {:x-amz-target ""}
                                                                                :content-type :json
                                                                                :form-params {:DomainId ""
                                                                                              :SpaceName ""
                                                                                              :Tags ""
                                                                                              :SpaceSettings ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateSpace"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"DomainId\": \"\",\n  \"SpaceName\": \"\",\n  \"Tags\": \"\",\n  \"SpaceSettings\": \"\"\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=SageMaker.CreateSpace"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"DomainId\": \"\",\n  \"SpaceName\": \"\",\n  \"Tags\": \"\",\n  \"SpaceSettings\": \"\"\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=SageMaker.CreateSpace");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DomainId\": \"\",\n  \"SpaceName\": \"\",\n  \"Tags\": \"\",\n  \"SpaceSettings\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateSpace"

	payload := strings.NewReader("{\n  \"DomainId\": \"\",\n  \"SpaceName\": \"\",\n  \"Tags\": \"\",\n  \"SpaceSettings\": \"\"\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: 76

{
  "DomainId": "",
  "SpaceName": "",
  "Tags": "",
  "SpaceSettings": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateSpace")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DomainId\": \"\",\n  \"SpaceName\": \"\",\n  \"Tags\": \"\",\n  \"SpaceSettings\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateSpace"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"DomainId\": \"\",\n  \"SpaceName\": \"\",\n  \"Tags\": \"\",\n  \"SpaceSettings\": \"\"\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  \"DomainId\": \"\",\n  \"SpaceName\": \"\",\n  \"Tags\": \"\",\n  \"SpaceSettings\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateSpace")
  .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=SageMaker.CreateSpace")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"DomainId\": \"\",\n  \"SpaceName\": \"\",\n  \"Tags\": \"\",\n  \"SpaceSettings\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  DomainId: '',
  SpaceName: '',
  Tags: '',
  SpaceSettings: ''
});

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=SageMaker.CreateSpace');
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=SageMaker.CreateSpace',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {DomainId: '', SpaceName: '', Tags: '', SpaceSettings: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateSpace';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DomainId":"","SpaceName":"","Tags":"","SpaceSettings":""}'
};

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=SageMaker.CreateSpace',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DomainId": "",\n  "SpaceName": "",\n  "Tags": "",\n  "SpaceSettings": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DomainId\": \"\",\n  \"SpaceName\": \"\",\n  \"Tags\": \"\",\n  \"SpaceSettings\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateSpace")
  .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({DomainId: '', SpaceName: '', Tags: '', SpaceSettings: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateSpace',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {DomainId: '', SpaceName: '', Tags: '', SpaceSettings: ''},
  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=SageMaker.CreateSpace');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  DomainId: '',
  SpaceName: '',
  Tags: '',
  SpaceSettings: ''
});

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=SageMaker.CreateSpace',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {DomainId: '', SpaceName: '', Tags: '', SpaceSettings: ''}
};

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=SageMaker.CreateSpace';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DomainId":"","SpaceName":"","Tags":"","SpaceSettings":""}'
};

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 = @{ @"DomainId": @"",
                              @"SpaceName": @"",
                              @"Tags": @"",
                              @"SpaceSettings": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreateSpace"]
                                                       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=SageMaker.CreateSpace" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"DomainId\": \"\",\n  \"SpaceName\": \"\",\n  \"Tags\": \"\",\n  \"SpaceSettings\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateSpace",
  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([
    'DomainId' => '',
    'SpaceName' => '',
    'Tags' => '',
    'SpaceSettings' => ''
  ]),
  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=SageMaker.CreateSpace', [
  'body' => '{
  "DomainId": "",
  "SpaceName": "",
  "Tags": "",
  "SpaceSettings": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateSpace');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DomainId' => '',
  'SpaceName' => '',
  'Tags' => '',
  'SpaceSettings' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'DomainId' => '',
  'SpaceName' => '',
  'Tags' => '',
  'SpaceSettings' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateSpace');
$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=SageMaker.CreateSpace' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DomainId": "",
  "SpaceName": "",
  "Tags": "",
  "SpaceSettings": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateSpace' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DomainId": "",
  "SpaceName": "",
  "Tags": "",
  "SpaceSettings": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"DomainId\": \"\",\n  \"SpaceName\": \"\",\n  \"Tags\": \"\",\n  \"SpaceSettings\": \"\"\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=SageMaker.CreateSpace"

payload = {
    "DomainId": "",
    "SpaceName": "",
    "Tags": "",
    "SpaceSettings": ""
}
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=SageMaker.CreateSpace"

payload <- "{\n  \"DomainId\": \"\",\n  \"SpaceName\": \"\",\n  \"Tags\": \"\",\n  \"SpaceSettings\": \"\"\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=SageMaker.CreateSpace")

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  \"DomainId\": \"\",\n  \"SpaceName\": \"\",\n  \"Tags\": \"\",\n  \"SpaceSettings\": \"\"\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  \"DomainId\": \"\",\n  \"SpaceName\": \"\",\n  \"Tags\": \"\",\n  \"SpaceSettings\": \"\"\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=SageMaker.CreateSpace";

    let payload = json!({
        "DomainId": "",
        "SpaceName": "",
        "Tags": "",
        "SpaceSettings": ""
    });

    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);
}

echo '{
  "DomainId": "",
  "SpaceName": "",
  "Tags": "",
  "SpaceSettings": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateSpace' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "DomainId": "",\n  "SpaceName": "",\n  "Tags": "",\n  "SpaceSettings": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateSpace'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "DomainId": "",
  "SpaceName": "",
  "Tags": "",
  "SpaceSettings": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateSpace")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateStudioLifecycleConfig");

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  \"StudioLifecycleConfigName\": \"\",\n  \"StudioLifecycleConfigContent\": \"\",\n  \"StudioLifecycleConfigAppType\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateStudioLifecycleConfig" {:headers {:x-amz-target ""}
                                                                                                :content-type :json
                                                                                                :form-params {:StudioLifecycleConfigName ""
                                                                                                              :StudioLifecycleConfigContent ""
                                                                                                              :StudioLifecycleConfigAppType ""
                                                                                                              :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateStudioLifecycleConfig"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"StudioLifecycleConfigName\": \"\",\n  \"StudioLifecycleConfigContent\": \"\",\n  \"StudioLifecycleConfigAppType\": \"\",\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=SageMaker.CreateStudioLifecycleConfig"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"StudioLifecycleConfigName\": \"\",\n  \"StudioLifecycleConfigContent\": \"\",\n  \"StudioLifecycleConfigAppType\": \"\",\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=SageMaker.CreateStudioLifecycleConfig");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"StudioLifecycleConfigName\": \"\",\n  \"StudioLifecycleConfigContent\": \"\",\n  \"StudioLifecycleConfigAppType\": \"\",\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=SageMaker.CreateStudioLifecycleConfig"

	payload := strings.NewReader("{\n  \"StudioLifecycleConfigName\": \"\",\n  \"StudioLifecycleConfigContent\": \"\",\n  \"StudioLifecycleConfigAppType\": \"\",\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: 127

{
  "StudioLifecycleConfigName": "",
  "StudioLifecycleConfigContent": "",
  "StudioLifecycleConfigAppType": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateStudioLifecycleConfig")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"StudioLifecycleConfigName\": \"\",\n  \"StudioLifecycleConfigContent\": \"\",\n  \"StudioLifecycleConfigAppType\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateStudioLifecycleConfig"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"StudioLifecycleConfigName\": \"\",\n  \"StudioLifecycleConfigContent\": \"\",\n  \"StudioLifecycleConfigAppType\": \"\",\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  \"StudioLifecycleConfigName\": \"\",\n  \"StudioLifecycleConfigContent\": \"\",\n  \"StudioLifecycleConfigAppType\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateStudioLifecycleConfig")
  .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=SageMaker.CreateStudioLifecycleConfig")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"StudioLifecycleConfigName\": \"\",\n  \"StudioLifecycleConfigContent\": \"\",\n  \"StudioLifecycleConfigAppType\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  StudioLifecycleConfigName: '',
  StudioLifecycleConfigContent: '',
  StudioLifecycleConfigAppType: '',
  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=SageMaker.CreateStudioLifecycleConfig');
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=SageMaker.CreateStudioLifecycleConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    StudioLifecycleConfigName: '',
    StudioLifecycleConfigContent: '',
    StudioLifecycleConfigAppType: '',
    Tags: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateStudioLifecycleConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"StudioLifecycleConfigName":"","StudioLifecycleConfigContent":"","StudioLifecycleConfigAppType":"","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=SageMaker.CreateStudioLifecycleConfig',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "StudioLifecycleConfigName": "",\n  "StudioLifecycleConfigContent": "",\n  "StudioLifecycleConfigAppType": "",\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  \"StudioLifecycleConfigName\": \"\",\n  \"StudioLifecycleConfigContent\": \"\",\n  \"StudioLifecycleConfigAppType\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateStudioLifecycleConfig")
  .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({
  StudioLifecycleConfigName: '',
  StudioLifecycleConfigContent: '',
  StudioLifecycleConfigAppType: '',
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateStudioLifecycleConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    StudioLifecycleConfigName: '',
    StudioLifecycleConfigContent: '',
    StudioLifecycleConfigAppType: '',
    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=SageMaker.CreateStudioLifecycleConfig');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  StudioLifecycleConfigName: '',
  StudioLifecycleConfigContent: '',
  StudioLifecycleConfigAppType: '',
  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=SageMaker.CreateStudioLifecycleConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    StudioLifecycleConfigName: '',
    StudioLifecycleConfigContent: '',
    StudioLifecycleConfigAppType: '',
    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=SageMaker.CreateStudioLifecycleConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"StudioLifecycleConfigName":"","StudioLifecycleConfigContent":"","StudioLifecycleConfigAppType":"","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 = @{ @"StudioLifecycleConfigName": @"",
                              @"StudioLifecycleConfigContent": @"",
                              @"StudioLifecycleConfigAppType": @"",
                              @"Tags": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreateStudioLifecycleConfig"]
                                                       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=SageMaker.CreateStudioLifecycleConfig" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"StudioLifecycleConfigName\": \"\",\n  \"StudioLifecycleConfigContent\": \"\",\n  \"StudioLifecycleConfigAppType\": \"\",\n  \"Tags\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateStudioLifecycleConfig",
  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([
    'StudioLifecycleConfigName' => '',
    'StudioLifecycleConfigContent' => '',
    'StudioLifecycleConfigAppType' => '',
    '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=SageMaker.CreateStudioLifecycleConfig', [
  'body' => '{
  "StudioLifecycleConfigName": "",
  "StudioLifecycleConfigContent": "",
  "StudioLifecycleConfigAppType": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateStudioLifecycleConfig');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'StudioLifecycleConfigName' => '',
  'StudioLifecycleConfigContent' => '',
  'StudioLifecycleConfigAppType' => '',
  'Tags' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'StudioLifecycleConfigName' => '',
  'StudioLifecycleConfigContent' => '',
  'StudioLifecycleConfigAppType' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateStudioLifecycleConfig');
$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=SageMaker.CreateStudioLifecycleConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "StudioLifecycleConfigName": "",
  "StudioLifecycleConfigContent": "",
  "StudioLifecycleConfigAppType": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateStudioLifecycleConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "StudioLifecycleConfigName": "",
  "StudioLifecycleConfigContent": "",
  "StudioLifecycleConfigAppType": "",
  "Tags": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"StudioLifecycleConfigName\": \"\",\n  \"StudioLifecycleConfigContent\": \"\",\n  \"StudioLifecycleConfigAppType\": \"\",\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=SageMaker.CreateStudioLifecycleConfig"

payload = {
    "StudioLifecycleConfigName": "",
    "StudioLifecycleConfigContent": "",
    "StudioLifecycleConfigAppType": "",
    "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=SageMaker.CreateStudioLifecycleConfig"

payload <- "{\n  \"StudioLifecycleConfigName\": \"\",\n  \"StudioLifecycleConfigContent\": \"\",\n  \"StudioLifecycleConfigAppType\": \"\",\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=SageMaker.CreateStudioLifecycleConfig")

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  \"StudioLifecycleConfigName\": \"\",\n  \"StudioLifecycleConfigContent\": \"\",\n  \"StudioLifecycleConfigAppType\": \"\",\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  \"StudioLifecycleConfigName\": \"\",\n  \"StudioLifecycleConfigContent\": \"\",\n  \"StudioLifecycleConfigAppType\": \"\",\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=SageMaker.CreateStudioLifecycleConfig";

    let payload = json!({
        "StudioLifecycleConfigName": "",
        "StudioLifecycleConfigContent": "",
        "StudioLifecycleConfigAppType": "",
        "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);
}

echo '{
  "StudioLifecycleConfigName": "",
  "StudioLifecycleConfigContent": "",
  "StudioLifecycleConfigAppType": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateStudioLifecycleConfig' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "StudioLifecycleConfigName": "",\n  "StudioLifecycleConfigContent": "",\n  "StudioLifecycleConfigAppType": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateStudioLifecycleConfig'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "StudioLifecycleConfigName": "",
  "StudioLifecycleConfigContent": "",
  "StudioLifecycleConfigAppType": "",
  "Tags": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateStudioLifecycleConfig")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTrainingJob");

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  \"TrainingJobName\": \"\",\n  \"HyperParameters\": \"\",\n  \"AlgorithmSpecification\": \"\",\n  \"RoleArn\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ResourceConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\n  \"Tags\": \"\",\n  \"EnableNetworkIsolation\": \"\",\n  \"EnableInterContainerTrafficEncryption\": \"\",\n  \"EnableManagedSpotTraining\": \"\",\n  \"CheckpointConfig\": \"\",\n  \"DebugHookConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\",\n    \"HookParameters\": \"\",\n    \"CollectionConfigurations\": \"\"\n  },\n  \"DebugRuleConfigurations\": \"\",\n  \"TensorBoardOutputConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\"\n  },\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  },\n  \"ProfilerConfig\": {\n    \"S3OutputPath\": \"\",\n    \"ProfilingIntervalInMilliseconds\": \"\",\n    \"ProfilingParameters\": \"\",\n    \"DisableProfiler\": \"\"\n  },\n  \"ProfilerRuleConfigurations\": \"\",\n  \"Environment\": \"\",\n  \"RetryStrategy\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTrainingJob" {:headers {:x-amz-target ""}
                                                                                      :content-type :json
                                                                                      :form-params {:TrainingJobName ""
                                                                                                    :HyperParameters ""
                                                                                                    :AlgorithmSpecification ""
                                                                                                    :RoleArn ""
                                                                                                    :InputDataConfig ""
                                                                                                    :OutputDataConfig ""
                                                                                                    :ResourceConfig ""
                                                                                                    :VpcConfig ""
                                                                                                    :StoppingCondition ""
                                                                                                    :Tags ""
                                                                                                    :EnableNetworkIsolation ""
                                                                                                    :EnableInterContainerTrafficEncryption ""
                                                                                                    :EnableManagedSpotTraining ""
                                                                                                    :CheckpointConfig ""
                                                                                                    :DebugHookConfig {:LocalPath ""
                                                                                                                      :S3OutputPath ""
                                                                                                                      :HookParameters ""
                                                                                                                      :CollectionConfigurations ""}
                                                                                                    :DebugRuleConfigurations ""
                                                                                                    :TensorBoardOutputConfig {:LocalPath ""
                                                                                                                              :S3OutputPath ""}
                                                                                                    :ExperimentConfig {:ExperimentName ""
                                                                                                                       :TrialName ""
                                                                                                                       :TrialComponentDisplayName ""
                                                                                                                       :RunName ""}
                                                                                                    :ProfilerConfig {:S3OutputPath ""
                                                                                                                     :ProfilingIntervalInMilliseconds ""
                                                                                                                     :ProfilingParameters ""
                                                                                                                     :DisableProfiler ""}
                                                                                                    :ProfilerRuleConfigurations ""
                                                                                                    :Environment ""
                                                                                                    :RetryStrategy ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTrainingJob"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TrainingJobName\": \"\",\n  \"HyperParameters\": \"\",\n  \"AlgorithmSpecification\": \"\",\n  \"RoleArn\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ResourceConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\n  \"Tags\": \"\",\n  \"EnableNetworkIsolation\": \"\",\n  \"EnableInterContainerTrafficEncryption\": \"\",\n  \"EnableManagedSpotTraining\": \"\",\n  \"CheckpointConfig\": \"\",\n  \"DebugHookConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\",\n    \"HookParameters\": \"\",\n    \"CollectionConfigurations\": \"\"\n  },\n  \"DebugRuleConfigurations\": \"\",\n  \"TensorBoardOutputConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\"\n  },\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  },\n  \"ProfilerConfig\": {\n    \"S3OutputPath\": \"\",\n    \"ProfilingIntervalInMilliseconds\": \"\",\n    \"ProfilingParameters\": \"\",\n    \"DisableProfiler\": \"\"\n  },\n  \"ProfilerRuleConfigurations\": \"\",\n  \"Environment\": \"\",\n  \"RetryStrategy\": \"\"\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=SageMaker.CreateTrainingJob"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TrainingJobName\": \"\",\n  \"HyperParameters\": \"\",\n  \"AlgorithmSpecification\": \"\",\n  \"RoleArn\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ResourceConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\n  \"Tags\": \"\",\n  \"EnableNetworkIsolation\": \"\",\n  \"EnableInterContainerTrafficEncryption\": \"\",\n  \"EnableManagedSpotTraining\": \"\",\n  \"CheckpointConfig\": \"\",\n  \"DebugHookConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\",\n    \"HookParameters\": \"\",\n    \"CollectionConfigurations\": \"\"\n  },\n  \"DebugRuleConfigurations\": \"\",\n  \"TensorBoardOutputConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\"\n  },\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  },\n  \"ProfilerConfig\": {\n    \"S3OutputPath\": \"\",\n    \"ProfilingIntervalInMilliseconds\": \"\",\n    \"ProfilingParameters\": \"\",\n    \"DisableProfiler\": \"\"\n  },\n  \"ProfilerRuleConfigurations\": \"\",\n  \"Environment\": \"\",\n  \"RetryStrategy\": \"\"\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=SageMaker.CreateTrainingJob");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TrainingJobName\": \"\",\n  \"HyperParameters\": \"\",\n  \"AlgorithmSpecification\": \"\",\n  \"RoleArn\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ResourceConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\n  \"Tags\": \"\",\n  \"EnableNetworkIsolation\": \"\",\n  \"EnableInterContainerTrafficEncryption\": \"\",\n  \"EnableManagedSpotTraining\": \"\",\n  \"CheckpointConfig\": \"\",\n  \"DebugHookConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\",\n    \"HookParameters\": \"\",\n    \"CollectionConfigurations\": \"\"\n  },\n  \"DebugRuleConfigurations\": \"\",\n  \"TensorBoardOutputConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\"\n  },\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  },\n  \"ProfilerConfig\": {\n    \"S3OutputPath\": \"\",\n    \"ProfilingIntervalInMilliseconds\": \"\",\n    \"ProfilingParameters\": \"\",\n    \"DisableProfiler\": \"\"\n  },\n  \"ProfilerRuleConfigurations\": \"\",\n  \"Environment\": \"\",\n  \"RetryStrategy\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTrainingJob"

	payload := strings.NewReader("{\n  \"TrainingJobName\": \"\",\n  \"HyperParameters\": \"\",\n  \"AlgorithmSpecification\": \"\",\n  \"RoleArn\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ResourceConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\n  \"Tags\": \"\",\n  \"EnableNetworkIsolation\": \"\",\n  \"EnableInterContainerTrafficEncryption\": \"\",\n  \"EnableManagedSpotTraining\": \"\",\n  \"CheckpointConfig\": \"\",\n  \"DebugHookConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\",\n    \"HookParameters\": \"\",\n    \"CollectionConfigurations\": \"\"\n  },\n  \"DebugRuleConfigurations\": \"\",\n  \"TensorBoardOutputConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\"\n  },\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  },\n  \"ProfilerConfig\": {\n    \"S3OutputPath\": \"\",\n    \"ProfilingIntervalInMilliseconds\": \"\",\n    \"ProfilingParameters\": \"\",\n    \"DisableProfiler\": \"\"\n  },\n  \"ProfilerRuleConfigurations\": \"\",\n  \"Environment\": \"\",\n  \"RetryStrategy\": \"\"\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: 985

{
  "TrainingJobName": "",
  "HyperParameters": "",
  "AlgorithmSpecification": "",
  "RoleArn": "",
  "InputDataConfig": "",
  "OutputDataConfig": "",
  "ResourceConfig": "",
  "VpcConfig": "",
  "StoppingCondition": "",
  "Tags": "",
  "EnableNetworkIsolation": "",
  "EnableInterContainerTrafficEncryption": "",
  "EnableManagedSpotTraining": "",
  "CheckpointConfig": "",
  "DebugHookConfig": {
    "LocalPath": "",
    "S3OutputPath": "",
    "HookParameters": "",
    "CollectionConfigurations": ""
  },
  "DebugRuleConfigurations": "",
  "TensorBoardOutputConfig": {
    "LocalPath": "",
    "S3OutputPath": ""
  },
  "ExperimentConfig": {
    "ExperimentName": "",
    "TrialName": "",
    "TrialComponentDisplayName": "",
    "RunName": ""
  },
  "ProfilerConfig": {
    "S3OutputPath": "",
    "ProfilingIntervalInMilliseconds": "",
    "ProfilingParameters": "",
    "DisableProfiler": ""
  },
  "ProfilerRuleConfigurations": "",
  "Environment": "",
  "RetryStrategy": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTrainingJob")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TrainingJobName\": \"\",\n  \"HyperParameters\": \"\",\n  \"AlgorithmSpecification\": \"\",\n  \"RoleArn\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ResourceConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\n  \"Tags\": \"\",\n  \"EnableNetworkIsolation\": \"\",\n  \"EnableInterContainerTrafficEncryption\": \"\",\n  \"EnableManagedSpotTraining\": \"\",\n  \"CheckpointConfig\": \"\",\n  \"DebugHookConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\",\n    \"HookParameters\": \"\",\n    \"CollectionConfigurations\": \"\"\n  },\n  \"DebugRuleConfigurations\": \"\",\n  \"TensorBoardOutputConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\"\n  },\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  },\n  \"ProfilerConfig\": {\n    \"S3OutputPath\": \"\",\n    \"ProfilingIntervalInMilliseconds\": \"\",\n    \"ProfilingParameters\": \"\",\n    \"DisableProfiler\": \"\"\n  },\n  \"ProfilerRuleConfigurations\": \"\",\n  \"Environment\": \"\",\n  \"RetryStrategy\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTrainingJob"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TrainingJobName\": \"\",\n  \"HyperParameters\": \"\",\n  \"AlgorithmSpecification\": \"\",\n  \"RoleArn\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ResourceConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\n  \"Tags\": \"\",\n  \"EnableNetworkIsolation\": \"\",\n  \"EnableInterContainerTrafficEncryption\": \"\",\n  \"EnableManagedSpotTraining\": \"\",\n  \"CheckpointConfig\": \"\",\n  \"DebugHookConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\",\n    \"HookParameters\": \"\",\n    \"CollectionConfigurations\": \"\"\n  },\n  \"DebugRuleConfigurations\": \"\",\n  \"TensorBoardOutputConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\"\n  },\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  },\n  \"ProfilerConfig\": {\n    \"S3OutputPath\": \"\",\n    \"ProfilingIntervalInMilliseconds\": \"\",\n    \"ProfilingParameters\": \"\",\n    \"DisableProfiler\": \"\"\n  },\n  \"ProfilerRuleConfigurations\": \"\",\n  \"Environment\": \"\",\n  \"RetryStrategy\": \"\"\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  \"TrainingJobName\": \"\",\n  \"HyperParameters\": \"\",\n  \"AlgorithmSpecification\": \"\",\n  \"RoleArn\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ResourceConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\n  \"Tags\": \"\",\n  \"EnableNetworkIsolation\": \"\",\n  \"EnableInterContainerTrafficEncryption\": \"\",\n  \"EnableManagedSpotTraining\": \"\",\n  \"CheckpointConfig\": \"\",\n  \"DebugHookConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\",\n    \"HookParameters\": \"\",\n    \"CollectionConfigurations\": \"\"\n  },\n  \"DebugRuleConfigurations\": \"\",\n  \"TensorBoardOutputConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\"\n  },\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  },\n  \"ProfilerConfig\": {\n    \"S3OutputPath\": \"\",\n    \"ProfilingIntervalInMilliseconds\": \"\",\n    \"ProfilingParameters\": \"\",\n    \"DisableProfiler\": \"\"\n  },\n  \"ProfilerRuleConfigurations\": \"\",\n  \"Environment\": \"\",\n  \"RetryStrategy\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTrainingJob")
  .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=SageMaker.CreateTrainingJob")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TrainingJobName\": \"\",\n  \"HyperParameters\": \"\",\n  \"AlgorithmSpecification\": \"\",\n  \"RoleArn\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ResourceConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\n  \"Tags\": \"\",\n  \"EnableNetworkIsolation\": \"\",\n  \"EnableInterContainerTrafficEncryption\": \"\",\n  \"EnableManagedSpotTraining\": \"\",\n  \"CheckpointConfig\": \"\",\n  \"DebugHookConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\",\n    \"HookParameters\": \"\",\n    \"CollectionConfigurations\": \"\"\n  },\n  \"DebugRuleConfigurations\": \"\",\n  \"TensorBoardOutputConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\"\n  },\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  },\n  \"ProfilerConfig\": {\n    \"S3OutputPath\": \"\",\n    \"ProfilingIntervalInMilliseconds\": \"\",\n    \"ProfilingParameters\": \"\",\n    \"DisableProfiler\": \"\"\n  },\n  \"ProfilerRuleConfigurations\": \"\",\n  \"Environment\": \"\",\n  \"RetryStrategy\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TrainingJobName: '',
  HyperParameters: '',
  AlgorithmSpecification: '',
  RoleArn: '',
  InputDataConfig: '',
  OutputDataConfig: '',
  ResourceConfig: '',
  VpcConfig: '',
  StoppingCondition: '',
  Tags: '',
  EnableNetworkIsolation: '',
  EnableInterContainerTrafficEncryption: '',
  EnableManagedSpotTraining: '',
  CheckpointConfig: '',
  DebugHookConfig: {
    LocalPath: '',
    S3OutputPath: '',
    HookParameters: '',
    CollectionConfigurations: ''
  },
  DebugRuleConfigurations: '',
  TensorBoardOutputConfig: {
    LocalPath: '',
    S3OutputPath: ''
  },
  ExperimentConfig: {
    ExperimentName: '',
    TrialName: '',
    TrialComponentDisplayName: '',
    RunName: ''
  },
  ProfilerConfig: {
    S3OutputPath: '',
    ProfilingIntervalInMilliseconds: '',
    ProfilingParameters: '',
    DisableProfiler: ''
  },
  ProfilerRuleConfigurations: '',
  Environment: '',
  RetryStrategy: ''
});

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=SageMaker.CreateTrainingJob');
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=SageMaker.CreateTrainingJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TrainingJobName: '',
    HyperParameters: '',
    AlgorithmSpecification: '',
    RoleArn: '',
    InputDataConfig: '',
    OutputDataConfig: '',
    ResourceConfig: '',
    VpcConfig: '',
    StoppingCondition: '',
    Tags: '',
    EnableNetworkIsolation: '',
    EnableInterContainerTrafficEncryption: '',
    EnableManagedSpotTraining: '',
    CheckpointConfig: '',
    DebugHookConfig: {
      LocalPath: '',
      S3OutputPath: '',
      HookParameters: '',
      CollectionConfigurations: ''
    },
    DebugRuleConfigurations: '',
    TensorBoardOutputConfig: {LocalPath: '', S3OutputPath: ''},
    ExperimentConfig: {ExperimentName: '', TrialName: '', TrialComponentDisplayName: '', RunName: ''},
    ProfilerConfig: {
      S3OutputPath: '',
      ProfilingIntervalInMilliseconds: '',
      ProfilingParameters: '',
      DisableProfiler: ''
    },
    ProfilerRuleConfigurations: '',
    Environment: '',
    RetryStrategy: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTrainingJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TrainingJobName":"","HyperParameters":"","AlgorithmSpecification":"","RoleArn":"","InputDataConfig":"","OutputDataConfig":"","ResourceConfig":"","VpcConfig":"","StoppingCondition":"","Tags":"","EnableNetworkIsolation":"","EnableInterContainerTrafficEncryption":"","EnableManagedSpotTraining":"","CheckpointConfig":"","DebugHookConfig":{"LocalPath":"","S3OutputPath":"","HookParameters":"","CollectionConfigurations":""},"DebugRuleConfigurations":"","TensorBoardOutputConfig":{"LocalPath":"","S3OutputPath":""},"ExperimentConfig":{"ExperimentName":"","TrialName":"","TrialComponentDisplayName":"","RunName":""},"ProfilerConfig":{"S3OutputPath":"","ProfilingIntervalInMilliseconds":"","ProfilingParameters":"","DisableProfiler":""},"ProfilerRuleConfigurations":"","Environment":"","RetryStrategy":""}'
};

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=SageMaker.CreateTrainingJob',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TrainingJobName": "",\n  "HyperParameters": "",\n  "AlgorithmSpecification": "",\n  "RoleArn": "",\n  "InputDataConfig": "",\n  "OutputDataConfig": "",\n  "ResourceConfig": "",\n  "VpcConfig": "",\n  "StoppingCondition": "",\n  "Tags": "",\n  "EnableNetworkIsolation": "",\n  "EnableInterContainerTrafficEncryption": "",\n  "EnableManagedSpotTraining": "",\n  "CheckpointConfig": "",\n  "DebugHookConfig": {\n    "LocalPath": "",\n    "S3OutputPath": "",\n    "HookParameters": "",\n    "CollectionConfigurations": ""\n  },\n  "DebugRuleConfigurations": "",\n  "TensorBoardOutputConfig": {\n    "LocalPath": "",\n    "S3OutputPath": ""\n  },\n  "ExperimentConfig": {\n    "ExperimentName": "",\n    "TrialName": "",\n    "TrialComponentDisplayName": "",\n    "RunName": ""\n  },\n  "ProfilerConfig": {\n    "S3OutputPath": "",\n    "ProfilingIntervalInMilliseconds": "",\n    "ProfilingParameters": "",\n    "DisableProfiler": ""\n  },\n  "ProfilerRuleConfigurations": "",\n  "Environment": "",\n  "RetryStrategy": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TrainingJobName\": \"\",\n  \"HyperParameters\": \"\",\n  \"AlgorithmSpecification\": \"\",\n  \"RoleArn\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ResourceConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\n  \"Tags\": \"\",\n  \"EnableNetworkIsolation\": \"\",\n  \"EnableInterContainerTrafficEncryption\": \"\",\n  \"EnableManagedSpotTraining\": \"\",\n  \"CheckpointConfig\": \"\",\n  \"DebugHookConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\",\n    \"HookParameters\": \"\",\n    \"CollectionConfigurations\": \"\"\n  },\n  \"DebugRuleConfigurations\": \"\",\n  \"TensorBoardOutputConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\"\n  },\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  },\n  \"ProfilerConfig\": {\n    \"S3OutputPath\": \"\",\n    \"ProfilingIntervalInMilliseconds\": \"\",\n    \"ProfilingParameters\": \"\",\n    \"DisableProfiler\": \"\"\n  },\n  \"ProfilerRuleConfigurations\": \"\",\n  \"Environment\": \"\",\n  \"RetryStrategy\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTrainingJob")
  .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({
  TrainingJobName: '',
  HyperParameters: '',
  AlgorithmSpecification: '',
  RoleArn: '',
  InputDataConfig: '',
  OutputDataConfig: '',
  ResourceConfig: '',
  VpcConfig: '',
  StoppingCondition: '',
  Tags: '',
  EnableNetworkIsolation: '',
  EnableInterContainerTrafficEncryption: '',
  EnableManagedSpotTraining: '',
  CheckpointConfig: '',
  DebugHookConfig: {
    LocalPath: '',
    S3OutputPath: '',
    HookParameters: '',
    CollectionConfigurations: ''
  },
  DebugRuleConfigurations: '',
  TensorBoardOutputConfig: {LocalPath: '', S3OutputPath: ''},
  ExperimentConfig: {ExperimentName: '', TrialName: '', TrialComponentDisplayName: '', RunName: ''},
  ProfilerConfig: {
    S3OutputPath: '',
    ProfilingIntervalInMilliseconds: '',
    ProfilingParameters: '',
    DisableProfiler: ''
  },
  ProfilerRuleConfigurations: '',
  Environment: '',
  RetryStrategy: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTrainingJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    TrainingJobName: '',
    HyperParameters: '',
    AlgorithmSpecification: '',
    RoleArn: '',
    InputDataConfig: '',
    OutputDataConfig: '',
    ResourceConfig: '',
    VpcConfig: '',
    StoppingCondition: '',
    Tags: '',
    EnableNetworkIsolation: '',
    EnableInterContainerTrafficEncryption: '',
    EnableManagedSpotTraining: '',
    CheckpointConfig: '',
    DebugHookConfig: {
      LocalPath: '',
      S3OutputPath: '',
      HookParameters: '',
      CollectionConfigurations: ''
    },
    DebugRuleConfigurations: '',
    TensorBoardOutputConfig: {LocalPath: '', S3OutputPath: ''},
    ExperimentConfig: {ExperimentName: '', TrialName: '', TrialComponentDisplayName: '', RunName: ''},
    ProfilerConfig: {
      S3OutputPath: '',
      ProfilingIntervalInMilliseconds: '',
      ProfilingParameters: '',
      DisableProfiler: ''
    },
    ProfilerRuleConfigurations: '',
    Environment: '',
    RetryStrategy: ''
  },
  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=SageMaker.CreateTrainingJob');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TrainingJobName: '',
  HyperParameters: '',
  AlgorithmSpecification: '',
  RoleArn: '',
  InputDataConfig: '',
  OutputDataConfig: '',
  ResourceConfig: '',
  VpcConfig: '',
  StoppingCondition: '',
  Tags: '',
  EnableNetworkIsolation: '',
  EnableInterContainerTrafficEncryption: '',
  EnableManagedSpotTraining: '',
  CheckpointConfig: '',
  DebugHookConfig: {
    LocalPath: '',
    S3OutputPath: '',
    HookParameters: '',
    CollectionConfigurations: ''
  },
  DebugRuleConfigurations: '',
  TensorBoardOutputConfig: {
    LocalPath: '',
    S3OutputPath: ''
  },
  ExperimentConfig: {
    ExperimentName: '',
    TrialName: '',
    TrialComponentDisplayName: '',
    RunName: ''
  },
  ProfilerConfig: {
    S3OutputPath: '',
    ProfilingIntervalInMilliseconds: '',
    ProfilingParameters: '',
    DisableProfiler: ''
  },
  ProfilerRuleConfigurations: '',
  Environment: '',
  RetryStrategy: ''
});

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=SageMaker.CreateTrainingJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TrainingJobName: '',
    HyperParameters: '',
    AlgorithmSpecification: '',
    RoleArn: '',
    InputDataConfig: '',
    OutputDataConfig: '',
    ResourceConfig: '',
    VpcConfig: '',
    StoppingCondition: '',
    Tags: '',
    EnableNetworkIsolation: '',
    EnableInterContainerTrafficEncryption: '',
    EnableManagedSpotTraining: '',
    CheckpointConfig: '',
    DebugHookConfig: {
      LocalPath: '',
      S3OutputPath: '',
      HookParameters: '',
      CollectionConfigurations: ''
    },
    DebugRuleConfigurations: '',
    TensorBoardOutputConfig: {LocalPath: '', S3OutputPath: ''},
    ExperimentConfig: {ExperimentName: '', TrialName: '', TrialComponentDisplayName: '', RunName: ''},
    ProfilerConfig: {
      S3OutputPath: '',
      ProfilingIntervalInMilliseconds: '',
      ProfilingParameters: '',
      DisableProfiler: ''
    },
    ProfilerRuleConfigurations: '',
    Environment: '',
    RetryStrategy: ''
  }
};

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=SageMaker.CreateTrainingJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TrainingJobName":"","HyperParameters":"","AlgorithmSpecification":"","RoleArn":"","InputDataConfig":"","OutputDataConfig":"","ResourceConfig":"","VpcConfig":"","StoppingCondition":"","Tags":"","EnableNetworkIsolation":"","EnableInterContainerTrafficEncryption":"","EnableManagedSpotTraining":"","CheckpointConfig":"","DebugHookConfig":{"LocalPath":"","S3OutputPath":"","HookParameters":"","CollectionConfigurations":""},"DebugRuleConfigurations":"","TensorBoardOutputConfig":{"LocalPath":"","S3OutputPath":""},"ExperimentConfig":{"ExperimentName":"","TrialName":"","TrialComponentDisplayName":"","RunName":""},"ProfilerConfig":{"S3OutputPath":"","ProfilingIntervalInMilliseconds":"","ProfilingParameters":"","DisableProfiler":""},"ProfilerRuleConfigurations":"","Environment":"","RetryStrategy":""}'
};

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 = @{ @"TrainingJobName": @"",
                              @"HyperParameters": @"",
                              @"AlgorithmSpecification": @"",
                              @"RoleArn": @"",
                              @"InputDataConfig": @"",
                              @"OutputDataConfig": @"",
                              @"ResourceConfig": @"",
                              @"VpcConfig": @"",
                              @"StoppingCondition": @"",
                              @"Tags": @"",
                              @"EnableNetworkIsolation": @"",
                              @"EnableInterContainerTrafficEncryption": @"",
                              @"EnableManagedSpotTraining": @"",
                              @"CheckpointConfig": @"",
                              @"DebugHookConfig": @{ @"LocalPath": @"", @"S3OutputPath": @"", @"HookParameters": @"", @"CollectionConfigurations": @"" },
                              @"DebugRuleConfigurations": @"",
                              @"TensorBoardOutputConfig": @{ @"LocalPath": @"", @"S3OutputPath": @"" },
                              @"ExperimentConfig": @{ @"ExperimentName": @"", @"TrialName": @"", @"TrialComponentDisplayName": @"", @"RunName": @"" },
                              @"ProfilerConfig": @{ @"S3OutputPath": @"", @"ProfilingIntervalInMilliseconds": @"", @"ProfilingParameters": @"", @"DisableProfiler": @"" },
                              @"ProfilerRuleConfigurations": @"",
                              @"Environment": @"",
                              @"RetryStrategy": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTrainingJob"]
                                                       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=SageMaker.CreateTrainingJob" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TrainingJobName\": \"\",\n  \"HyperParameters\": \"\",\n  \"AlgorithmSpecification\": \"\",\n  \"RoleArn\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ResourceConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\n  \"Tags\": \"\",\n  \"EnableNetworkIsolation\": \"\",\n  \"EnableInterContainerTrafficEncryption\": \"\",\n  \"EnableManagedSpotTraining\": \"\",\n  \"CheckpointConfig\": \"\",\n  \"DebugHookConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\",\n    \"HookParameters\": \"\",\n    \"CollectionConfigurations\": \"\"\n  },\n  \"DebugRuleConfigurations\": \"\",\n  \"TensorBoardOutputConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\"\n  },\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  },\n  \"ProfilerConfig\": {\n    \"S3OutputPath\": \"\",\n    \"ProfilingIntervalInMilliseconds\": \"\",\n    \"ProfilingParameters\": \"\",\n    \"DisableProfiler\": \"\"\n  },\n  \"ProfilerRuleConfigurations\": \"\",\n  \"Environment\": \"\",\n  \"RetryStrategy\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTrainingJob",
  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([
    'TrainingJobName' => '',
    'HyperParameters' => '',
    'AlgorithmSpecification' => '',
    'RoleArn' => '',
    'InputDataConfig' => '',
    'OutputDataConfig' => '',
    'ResourceConfig' => '',
    'VpcConfig' => '',
    'StoppingCondition' => '',
    'Tags' => '',
    'EnableNetworkIsolation' => '',
    'EnableInterContainerTrafficEncryption' => '',
    'EnableManagedSpotTraining' => '',
    'CheckpointConfig' => '',
    'DebugHookConfig' => [
        'LocalPath' => '',
        'S3OutputPath' => '',
        'HookParameters' => '',
        'CollectionConfigurations' => ''
    ],
    'DebugRuleConfigurations' => '',
    'TensorBoardOutputConfig' => [
        'LocalPath' => '',
        'S3OutputPath' => ''
    ],
    'ExperimentConfig' => [
        'ExperimentName' => '',
        'TrialName' => '',
        'TrialComponentDisplayName' => '',
        'RunName' => ''
    ],
    'ProfilerConfig' => [
        'S3OutputPath' => '',
        'ProfilingIntervalInMilliseconds' => '',
        'ProfilingParameters' => '',
        'DisableProfiler' => ''
    ],
    'ProfilerRuleConfigurations' => '',
    'Environment' => '',
    'RetryStrategy' => ''
  ]),
  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=SageMaker.CreateTrainingJob', [
  'body' => '{
  "TrainingJobName": "",
  "HyperParameters": "",
  "AlgorithmSpecification": "",
  "RoleArn": "",
  "InputDataConfig": "",
  "OutputDataConfig": "",
  "ResourceConfig": "",
  "VpcConfig": "",
  "StoppingCondition": "",
  "Tags": "",
  "EnableNetworkIsolation": "",
  "EnableInterContainerTrafficEncryption": "",
  "EnableManagedSpotTraining": "",
  "CheckpointConfig": "",
  "DebugHookConfig": {
    "LocalPath": "",
    "S3OutputPath": "",
    "HookParameters": "",
    "CollectionConfigurations": ""
  },
  "DebugRuleConfigurations": "",
  "TensorBoardOutputConfig": {
    "LocalPath": "",
    "S3OutputPath": ""
  },
  "ExperimentConfig": {
    "ExperimentName": "",
    "TrialName": "",
    "TrialComponentDisplayName": "",
    "RunName": ""
  },
  "ProfilerConfig": {
    "S3OutputPath": "",
    "ProfilingIntervalInMilliseconds": "",
    "ProfilingParameters": "",
    "DisableProfiler": ""
  },
  "ProfilerRuleConfigurations": "",
  "Environment": "",
  "RetryStrategy": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTrainingJob');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TrainingJobName' => '',
  'HyperParameters' => '',
  'AlgorithmSpecification' => '',
  'RoleArn' => '',
  'InputDataConfig' => '',
  'OutputDataConfig' => '',
  'ResourceConfig' => '',
  'VpcConfig' => '',
  'StoppingCondition' => '',
  'Tags' => '',
  'EnableNetworkIsolation' => '',
  'EnableInterContainerTrafficEncryption' => '',
  'EnableManagedSpotTraining' => '',
  'CheckpointConfig' => '',
  'DebugHookConfig' => [
    'LocalPath' => '',
    'S3OutputPath' => '',
    'HookParameters' => '',
    'CollectionConfigurations' => ''
  ],
  'DebugRuleConfigurations' => '',
  'TensorBoardOutputConfig' => [
    'LocalPath' => '',
    'S3OutputPath' => ''
  ],
  'ExperimentConfig' => [
    'ExperimentName' => '',
    'TrialName' => '',
    'TrialComponentDisplayName' => '',
    'RunName' => ''
  ],
  'ProfilerConfig' => [
    'S3OutputPath' => '',
    'ProfilingIntervalInMilliseconds' => '',
    'ProfilingParameters' => '',
    'DisableProfiler' => ''
  ],
  'ProfilerRuleConfigurations' => '',
  'Environment' => '',
  'RetryStrategy' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TrainingJobName' => '',
  'HyperParameters' => '',
  'AlgorithmSpecification' => '',
  'RoleArn' => '',
  'InputDataConfig' => '',
  'OutputDataConfig' => '',
  'ResourceConfig' => '',
  'VpcConfig' => '',
  'StoppingCondition' => '',
  'Tags' => '',
  'EnableNetworkIsolation' => '',
  'EnableInterContainerTrafficEncryption' => '',
  'EnableManagedSpotTraining' => '',
  'CheckpointConfig' => '',
  'DebugHookConfig' => [
    'LocalPath' => '',
    'S3OutputPath' => '',
    'HookParameters' => '',
    'CollectionConfigurations' => ''
  ],
  'DebugRuleConfigurations' => '',
  'TensorBoardOutputConfig' => [
    'LocalPath' => '',
    'S3OutputPath' => ''
  ],
  'ExperimentConfig' => [
    'ExperimentName' => '',
    'TrialName' => '',
    'TrialComponentDisplayName' => '',
    'RunName' => ''
  ],
  'ProfilerConfig' => [
    'S3OutputPath' => '',
    'ProfilingIntervalInMilliseconds' => '',
    'ProfilingParameters' => '',
    'DisableProfiler' => ''
  ],
  'ProfilerRuleConfigurations' => '',
  'Environment' => '',
  'RetryStrategy' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTrainingJob');
$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=SageMaker.CreateTrainingJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TrainingJobName": "",
  "HyperParameters": "",
  "AlgorithmSpecification": "",
  "RoleArn": "",
  "InputDataConfig": "",
  "OutputDataConfig": "",
  "ResourceConfig": "",
  "VpcConfig": "",
  "StoppingCondition": "",
  "Tags": "",
  "EnableNetworkIsolation": "",
  "EnableInterContainerTrafficEncryption": "",
  "EnableManagedSpotTraining": "",
  "CheckpointConfig": "",
  "DebugHookConfig": {
    "LocalPath": "",
    "S3OutputPath": "",
    "HookParameters": "",
    "CollectionConfigurations": ""
  },
  "DebugRuleConfigurations": "",
  "TensorBoardOutputConfig": {
    "LocalPath": "",
    "S3OutputPath": ""
  },
  "ExperimentConfig": {
    "ExperimentName": "",
    "TrialName": "",
    "TrialComponentDisplayName": "",
    "RunName": ""
  },
  "ProfilerConfig": {
    "S3OutputPath": "",
    "ProfilingIntervalInMilliseconds": "",
    "ProfilingParameters": "",
    "DisableProfiler": ""
  },
  "ProfilerRuleConfigurations": "",
  "Environment": "",
  "RetryStrategy": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTrainingJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TrainingJobName": "",
  "HyperParameters": "",
  "AlgorithmSpecification": "",
  "RoleArn": "",
  "InputDataConfig": "",
  "OutputDataConfig": "",
  "ResourceConfig": "",
  "VpcConfig": "",
  "StoppingCondition": "",
  "Tags": "",
  "EnableNetworkIsolation": "",
  "EnableInterContainerTrafficEncryption": "",
  "EnableManagedSpotTraining": "",
  "CheckpointConfig": "",
  "DebugHookConfig": {
    "LocalPath": "",
    "S3OutputPath": "",
    "HookParameters": "",
    "CollectionConfigurations": ""
  },
  "DebugRuleConfigurations": "",
  "TensorBoardOutputConfig": {
    "LocalPath": "",
    "S3OutputPath": ""
  },
  "ExperimentConfig": {
    "ExperimentName": "",
    "TrialName": "",
    "TrialComponentDisplayName": "",
    "RunName": ""
  },
  "ProfilerConfig": {
    "S3OutputPath": "",
    "ProfilingIntervalInMilliseconds": "",
    "ProfilingParameters": "",
    "DisableProfiler": ""
  },
  "ProfilerRuleConfigurations": "",
  "Environment": "",
  "RetryStrategy": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TrainingJobName\": \"\",\n  \"HyperParameters\": \"\",\n  \"AlgorithmSpecification\": \"\",\n  \"RoleArn\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ResourceConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\n  \"Tags\": \"\",\n  \"EnableNetworkIsolation\": \"\",\n  \"EnableInterContainerTrafficEncryption\": \"\",\n  \"EnableManagedSpotTraining\": \"\",\n  \"CheckpointConfig\": \"\",\n  \"DebugHookConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\",\n    \"HookParameters\": \"\",\n    \"CollectionConfigurations\": \"\"\n  },\n  \"DebugRuleConfigurations\": \"\",\n  \"TensorBoardOutputConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\"\n  },\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  },\n  \"ProfilerConfig\": {\n    \"S3OutputPath\": \"\",\n    \"ProfilingIntervalInMilliseconds\": \"\",\n    \"ProfilingParameters\": \"\",\n    \"DisableProfiler\": \"\"\n  },\n  \"ProfilerRuleConfigurations\": \"\",\n  \"Environment\": \"\",\n  \"RetryStrategy\": \"\"\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=SageMaker.CreateTrainingJob"

payload = {
    "TrainingJobName": "",
    "HyperParameters": "",
    "AlgorithmSpecification": "",
    "RoleArn": "",
    "InputDataConfig": "",
    "OutputDataConfig": "",
    "ResourceConfig": "",
    "VpcConfig": "",
    "StoppingCondition": "",
    "Tags": "",
    "EnableNetworkIsolation": "",
    "EnableInterContainerTrafficEncryption": "",
    "EnableManagedSpotTraining": "",
    "CheckpointConfig": "",
    "DebugHookConfig": {
        "LocalPath": "",
        "S3OutputPath": "",
        "HookParameters": "",
        "CollectionConfigurations": ""
    },
    "DebugRuleConfigurations": "",
    "TensorBoardOutputConfig": {
        "LocalPath": "",
        "S3OutputPath": ""
    },
    "ExperimentConfig": {
        "ExperimentName": "",
        "TrialName": "",
        "TrialComponentDisplayName": "",
        "RunName": ""
    },
    "ProfilerConfig": {
        "S3OutputPath": "",
        "ProfilingIntervalInMilliseconds": "",
        "ProfilingParameters": "",
        "DisableProfiler": ""
    },
    "ProfilerRuleConfigurations": "",
    "Environment": "",
    "RetryStrategy": ""
}
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=SageMaker.CreateTrainingJob"

payload <- "{\n  \"TrainingJobName\": \"\",\n  \"HyperParameters\": \"\",\n  \"AlgorithmSpecification\": \"\",\n  \"RoleArn\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ResourceConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\n  \"Tags\": \"\",\n  \"EnableNetworkIsolation\": \"\",\n  \"EnableInterContainerTrafficEncryption\": \"\",\n  \"EnableManagedSpotTraining\": \"\",\n  \"CheckpointConfig\": \"\",\n  \"DebugHookConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\",\n    \"HookParameters\": \"\",\n    \"CollectionConfigurations\": \"\"\n  },\n  \"DebugRuleConfigurations\": \"\",\n  \"TensorBoardOutputConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\"\n  },\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  },\n  \"ProfilerConfig\": {\n    \"S3OutputPath\": \"\",\n    \"ProfilingIntervalInMilliseconds\": \"\",\n    \"ProfilingParameters\": \"\",\n    \"DisableProfiler\": \"\"\n  },\n  \"ProfilerRuleConfigurations\": \"\",\n  \"Environment\": \"\",\n  \"RetryStrategy\": \"\"\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=SageMaker.CreateTrainingJob")

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  \"TrainingJobName\": \"\",\n  \"HyperParameters\": \"\",\n  \"AlgorithmSpecification\": \"\",\n  \"RoleArn\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ResourceConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\n  \"Tags\": \"\",\n  \"EnableNetworkIsolation\": \"\",\n  \"EnableInterContainerTrafficEncryption\": \"\",\n  \"EnableManagedSpotTraining\": \"\",\n  \"CheckpointConfig\": \"\",\n  \"DebugHookConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\",\n    \"HookParameters\": \"\",\n    \"CollectionConfigurations\": \"\"\n  },\n  \"DebugRuleConfigurations\": \"\",\n  \"TensorBoardOutputConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\"\n  },\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  },\n  \"ProfilerConfig\": {\n    \"S3OutputPath\": \"\",\n    \"ProfilingIntervalInMilliseconds\": \"\",\n    \"ProfilingParameters\": \"\",\n    \"DisableProfiler\": \"\"\n  },\n  \"ProfilerRuleConfigurations\": \"\",\n  \"Environment\": \"\",\n  \"RetryStrategy\": \"\"\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  \"TrainingJobName\": \"\",\n  \"HyperParameters\": \"\",\n  \"AlgorithmSpecification\": \"\",\n  \"RoleArn\": \"\",\n  \"InputDataConfig\": \"\",\n  \"OutputDataConfig\": \"\",\n  \"ResourceConfig\": \"\",\n  \"VpcConfig\": \"\",\n  \"StoppingCondition\": \"\",\n  \"Tags\": \"\",\n  \"EnableNetworkIsolation\": \"\",\n  \"EnableInterContainerTrafficEncryption\": \"\",\n  \"EnableManagedSpotTraining\": \"\",\n  \"CheckpointConfig\": \"\",\n  \"DebugHookConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\",\n    \"HookParameters\": \"\",\n    \"CollectionConfigurations\": \"\"\n  },\n  \"DebugRuleConfigurations\": \"\",\n  \"TensorBoardOutputConfig\": {\n    \"LocalPath\": \"\",\n    \"S3OutputPath\": \"\"\n  },\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  },\n  \"ProfilerConfig\": {\n    \"S3OutputPath\": \"\",\n    \"ProfilingIntervalInMilliseconds\": \"\",\n    \"ProfilingParameters\": \"\",\n    \"DisableProfiler\": \"\"\n  },\n  \"ProfilerRuleConfigurations\": \"\",\n  \"Environment\": \"\",\n  \"RetryStrategy\": \"\"\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=SageMaker.CreateTrainingJob";

    let payload = json!({
        "TrainingJobName": "",
        "HyperParameters": "",
        "AlgorithmSpecification": "",
        "RoleArn": "",
        "InputDataConfig": "",
        "OutputDataConfig": "",
        "ResourceConfig": "",
        "VpcConfig": "",
        "StoppingCondition": "",
        "Tags": "",
        "EnableNetworkIsolation": "",
        "EnableInterContainerTrafficEncryption": "",
        "EnableManagedSpotTraining": "",
        "CheckpointConfig": "",
        "DebugHookConfig": json!({
            "LocalPath": "",
            "S3OutputPath": "",
            "HookParameters": "",
            "CollectionConfigurations": ""
        }),
        "DebugRuleConfigurations": "",
        "TensorBoardOutputConfig": json!({
            "LocalPath": "",
            "S3OutputPath": ""
        }),
        "ExperimentConfig": json!({
            "ExperimentName": "",
            "TrialName": "",
            "TrialComponentDisplayName": "",
            "RunName": ""
        }),
        "ProfilerConfig": json!({
            "S3OutputPath": "",
            "ProfilingIntervalInMilliseconds": "",
            "ProfilingParameters": "",
            "DisableProfiler": ""
        }),
        "ProfilerRuleConfigurations": "",
        "Environment": "",
        "RetryStrategy": ""
    });

    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);
}

echo '{
  "TrainingJobName": "",
  "HyperParameters": "",
  "AlgorithmSpecification": "",
  "RoleArn": "",
  "InputDataConfig": "",
  "OutputDataConfig": "",
  "ResourceConfig": "",
  "VpcConfig": "",
  "StoppingCondition": "",
  "Tags": "",
  "EnableNetworkIsolation": "",
  "EnableInterContainerTrafficEncryption": "",
  "EnableManagedSpotTraining": "",
  "CheckpointConfig": "",
  "DebugHookConfig": {
    "LocalPath": "",
    "S3OutputPath": "",
    "HookParameters": "",
    "CollectionConfigurations": ""
  },
  "DebugRuleConfigurations": "",
  "TensorBoardOutputConfig": {
    "LocalPath": "",
    "S3OutputPath": ""
  },
  "ExperimentConfig": {
    "ExperimentName": "",
    "TrialName": "",
    "TrialComponentDisplayName": "",
    "RunName": ""
  },
  "ProfilerConfig": {
    "S3OutputPath": "",
    "ProfilingIntervalInMilliseconds": "",
    "ProfilingParameters": "",
    "DisableProfiler": ""
  },
  "ProfilerRuleConfigurations": "",
  "Environment": "",
  "RetryStrategy": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTrainingJob' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TrainingJobName": "",\n  "HyperParameters": "",\n  "AlgorithmSpecification": "",\n  "RoleArn": "",\n  "InputDataConfig": "",\n  "OutputDataConfig": "",\n  "ResourceConfig": "",\n  "VpcConfig": "",\n  "StoppingCondition": "",\n  "Tags": "",\n  "EnableNetworkIsolation": "",\n  "EnableInterContainerTrafficEncryption": "",\n  "EnableManagedSpotTraining": "",\n  "CheckpointConfig": "",\n  "DebugHookConfig": {\n    "LocalPath": "",\n    "S3OutputPath": "",\n    "HookParameters": "",\n    "CollectionConfigurations": ""\n  },\n  "DebugRuleConfigurations": "",\n  "TensorBoardOutputConfig": {\n    "LocalPath": "",\n    "S3OutputPath": ""\n  },\n  "ExperimentConfig": {\n    "ExperimentName": "",\n    "TrialName": "",\n    "TrialComponentDisplayName": "",\n    "RunName": ""\n  },\n  "ProfilerConfig": {\n    "S3OutputPath": "",\n    "ProfilingIntervalInMilliseconds": "",\n    "ProfilingParameters": "",\n    "DisableProfiler": ""\n  },\n  "ProfilerRuleConfigurations": "",\n  "Environment": "",\n  "RetryStrategy": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTrainingJob'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TrainingJobName": "",
  "HyperParameters": "",
  "AlgorithmSpecification": "",
  "RoleArn": "",
  "InputDataConfig": "",
  "OutputDataConfig": "",
  "ResourceConfig": "",
  "VpcConfig": "",
  "StoppingCondition": "",
  "Tags": "",
  "EnableNetworkIsolation": "",
  "EnableInterContainerTrafficEncryption": "",
  "EnableManagedSpotTraining": "",
  "CheckpointConfig": "",
  "DebugHookConfig": [
    "LocalPath": "",
    "S3OutputPath": "",
    "HookParameters": "",
    "CollectionConfigurations": ""
  ],
  "DebugRuleConfigurations": "",
  "TensorBoardOutputConfig": [
    "LocalPath": "",
    "S3OutputPath": ""
  ],
  "ExperimentConfig": [
    "ExperimentName": "",
    "TrialName": "",
    "TrialComponentDisplayName": "",
    "RunName": ""
  ],
  "ProfilerConfig": [
    "S3OutputPath": "",
    "ProfilingIntervalInMilliseconds": "",
    "ProfilingParameters": "",
    "DisableProfiler": ""
  ],
  "ProfilerRuleConfigurations": "",
  "Environment": "",
  "RetryStrategy": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTrainingJob")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTransformJob");

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  \"TransformJobName\": \"\",\n  \"ModelName\": \"\",\n  \"MaxConcurrentTransforms\": \"\",\n  \"ModelClientConfig\": \"\",\n  \"MaxPayloadInMB\": \"\",\n  \"BatchStrategy\": \"\",\n  \"Environment\": \"\",\n  \"TransformInput\": \"\",\n  \"TransformOutput\": \"\",\n  \"DataCaptureConfig\": \"\",\n  \"TransformResources\": \"\",\n  \"DataProcessing\": \"\",\n  \"Tags\": \"\",\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTransformJob" {:headers {:x-amz-target ""}
                                                                                       :content-type :json
                                                                                       :form-params {:TransformJobName ""
                                                                                                     :ModelName ""
                                                                                                     :MaxConcurrentTransforms ""
                                                                                                     :ModelClientConfig ""
                                                                                                     :MaxPayloadInMB ""
                                                                                                     :BatchStrategy ""
                                                                                                     :Environment ""
                                                                                                     :TransformInput ""
                                                                                                     :TransformOutput ""
                                                                                                     :DataCaptureConfig ""
                                                                                                     :TransformResources ""
                                                                                                     :DataProcessing ""
                                                                                                     :Tags ""
                                                                                                     :ExperimentConfig {:ExperimentName ""
                                                                                                                        :TrialName ""
                                                                                                                        :TrialComponentDisplayName ""
                                                                                                                        :RunName ""}}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTransformJob"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TransformJobName\": \"\",\n  \"ModelName\": \"\",\n  \"MaxConcurrentTransforms\": \"\",\n  \"ModelClientConfig\": \"\",\n  \"MaxPayloadInMB\": \"\",\n  \"BatchStrategy\": \"\",\n  \"Environment\": \"\",\n  \"TransformInput\": \"\",\n  \"TransformOutput\": \"\",\n  \"DataCaptureConfig\": \"\",\n  \"TransformResources\": \"\",\n  \"DataProcessing\": \"\",\n  \"Tags\": \"\",\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  }\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=SageMaker.CreateTransformJob"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TransformJobName\": \"\",\n  \"ModelName\": \"\",\n  \"MaxConcurrentTransforms\": \"\",\n  \"ModelClientConfig\": \"\",\n  \"MaxPayloadInMB\": \"\",\n  \"BatchStrategy\": \"\",\n  \"Environment\": \"\",\n  \"TransformInput\": \"\",\n  \"TransformOutput\": \"\",\n  \"DataCaptureConfig\": \"\",\n  \"TransformResources\": \"\",\n  \"DataProcessing\": \"\",\n  \"Tags\": \"\",\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  }\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=SageMaker.CreateTransformJob");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TransformJobName\": \"\",\n  \"ModelName\": \"\",\n  \"MaxConcurrentTransforms\": \"\",\n  \"ModelClientConfig\": \"\",\n  \"MaxPayloadInMB\": \"\",\n  \"BatchStrategy\": \"\",\n  \"Environment\": \"\",\n  \"TransformInput\": \"\",\n  \"TransformOutput\": \"\",\n  \"DataCaptureConfig\": \"\",\n  \"TransformResources\": \"\",\n  \"DataProcessing\": \"\",\n  \"Tags\": \"\",\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTransformJob"

	payload := strings.NewReader("{\n  \"TransformJobName\": \"\",\n  \"ModelName\": \"\",\n  \"MaxConcurrentTransforms\": \"\",\n  \"ModelClientConfig\": \"\",\n  \"MaxPayloadInMB\": \"\",\n  \"BatchStrategy\": \"\",\n  \"Environment\": \"\",\n  \"TransformInput\": \"\",\n  \"TransformOutput\": \"\",\n  \"DataCaptureConfig\": \"\",\n  \"TransformResources\": \"\",\n  \"DataProcessing\": \"\",\n  \"Tags\": \"\",\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  }\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: 448

{
  "TransformJobName": "",
  "ModelName": "",
  "MaxConcurrentTransforms": "",
  "ModelClientConfig": "",
  "MaxPayloadInMB": "",
  "BatchStrategy": "",
  "Environment": "",
  "TransformInput": "",
  "TransformOutput": "",
  "DataCaptureConfig": "",
  "TransformResources": "",
  "DataProcessing": "",
  "Tags": "",
  "ExperimentConfig": {
    "ExperimentName": "",
    "TrialName": "",
    "TrialComponentDisplayName": "",
    "RunName": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTransformJob")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TransformJobName\": \"\",\n  \"ModelName\": \"\",\n  \"MaxConcurrentTransforms\": \"\",\n  \"ModelClientConfig\": \"\",\n  \"MaxPayloadInMB\": \"\",\n  \"BatchStrategy\": \"\",\n  \"Environment\": \"\",\n  \"TransformInput\": \"\",\n  \"TransformOutput\": \"\",\n  \"DataCaptureConfig\": \"\",\n  \"TransformResources\": \"\",\n  \"DataProcessing\": \"\",\n  \"Tags\": \"\",\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTransformJob"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TransformJobName\": \"\",\n  \"ModelName\": \"\",\n  \"MaxConcurrentTransforms\": \"\",\n  \"ModelClientConfig\": \"\",\n  \"MaxPayloadInMB\": \"\",\n  \"BatchStrategy\": \"\",\n  \"Environment\": \"\",\n  \"TransformInput\": \"\",\n  \"TransformOutput\": \"\",\n  \"DataCaptureConfig\": \"\",\n  \"TransformResources\": \"\",\n  \"DataProcessing\": \"\",\n  \"Tags\": \"\",\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  }\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  \"TransformJobName\": \"\",\n  \"ModelName\": \"\",\n  \"MaxConcurrentTransforms\": \"\",\n  \"ModelClientConfig\": \"\",\n  \"MaxPayloadInMB\": \"\",\n  \"BatchStrategy\": \"\",\n  \"Environment\": \"\",\n  \"TransformInput\": \"\",\n  \"TransformOutput\": \"\",\n  \"DataCaptureConfig\": \"\",\n  \"TransformResources\": \"\",\n  \"DataProcessing\": \"\",\n  \"Tags\": \"\",\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTransformJob")
  .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=SageMaker.CreateTransformJob")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TransformJobName\": \"\",\n  \"ModelName\": \"\",\n  \"MaxConcurrentTransforms\": \"\",\n  \"ModelClientConfig\": \"\",\n  \"MaxPayloadInMB\": \"\",\n  \"BatchStrategy\": \"\",\n  \"Environment\": \"\",\n  \"TransformInput\": \"\",\n  \"TransformOutput\": \"\",\n  \"DataCaptureConfig\": \"\",\n  \"TransformResources\": \"\",\n  \"DataProcessing\": \"\",\n  \"Tags\": \"\",\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  TransformJobName: '',
  ModelName: '',
  MaxConcurrentTransforms: '',
  ModelClientConfig: '',
  MaxPayloadInMB: '',
  BatchStrategy: '',
  Environment: '',
  TransformInput: '',
  TransformOutput: '',
  DataCaptureConfig: '',
  TransformResources: '',
  DataProcessing: '',
  Tags: '',
  ExperimentConfig: {
    ExperimentName: '',
    TrialName: '',
    TrialComponentDisplayName: '',
    RunName: ''
  }
});

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=SageMaker.CreateTransformJob');
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=SageMaker.CreateTransformJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TransformJobName: '',
    ModelName: '',
    MaxConcurrentTransforms: '',
    ModelClientConfig: '',
    MaxPayloadInMB: '',
    BatchStrategy: '',
    Environment: '',
    TransformInput: '',
    TransformOutput: '',
    DataCaptureConfig: '',
    TransformResources: '',
    DataProcessing: '',
    Tags: '',
    ExperimentConfig: {ExperimentName: '', TrialName: '', TrialComponentDisplayName: '', RunName: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTransformJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TransformJobName":"","ModelName":"","MaxConcurrentTransforms":"","ModelClientConfig":"","MaxPayloadInMB":"","BatchStrategy":"","Environment":"","TransformInput":"","TransformOutput":"","DataCaptureConfig":"","TransformResources":"","DataProcessing":"","Tags":"","ExperimentConfig":{"ExperimentName":"","TrialName":"","TrialComponentDisplayName":"","RunName":""}}'
};

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=SageMaker.CreateTransformJob',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TransformJobName": "",\n  "ModelName": "",\n  "MaxConcurrentTransforms": "",\n  "ModelClientConfig": "",\n  "MaxPayloadInMB": "",\n  "BatchStrategy": "",\n  "Environment": "",\n  "TransformInput": "",\n  "TransformOutput": "",\n  "DataCaptureConfig": "",\n  "TransformResources": "",\n  "DataProcessing": "",\n  "Tags": "",\n  "ExperimentConfig": {\n    "ExperimentName": "",\n    "TrialName": "",\n    "TrialComponentDisplayName": "",\n    "RunName": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TransformJobName\": \"\",\n  \"ModelName\": \"\",\n  \"MaxConcurrentTransforms\": \"\",\n  \"ModelClientConfig\": \"\",\n  \"MaxPayloadInMB\": \"\",\n  \"BatchStrategy\": \"\",\n  \"Environment\": \"\",\n  \"TransformInput\": \"\",\n  \"TransformOutput\": \"\",\n  \"DataCaptureConfig\": \"\",\n  \"TransformResources\": \"\",\n  \"DataProcessing\": \"\",\n  \"Tags\": \"\",\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTransformJob")
  .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({
  TransformJobName: '',
  ModelName: '',
  MaxConcurrentTransforms: '',
  ModelClientConfig: '',
  MaxPayloadInMB: '',
  BatchStrategy: '',
  Environment: '',
  TransformInput: '',
  TransformOutput: '',
  DataCaptureConfig: '',
  TransformResources: '',
  DataProcessing: '',
  Tags: '',
  ExperimentConfig: {ExperimentName: '', TrialName: '', TrialComponentDisplayName: '', RunName: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTransformJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    TransformJobName: '',
    ModelName: '',
    MaxConcurrentTransforms: '',
    ModelClientConfig: '',
    MaxPayloadInMB: '',
    BatchStrategy: '',
    Environment: '',
    TransformInput: '',
    TransformOutput: '',
    DataCaptureConfig: '',
    TransformResources: '',
    DataProcessing: '',
    Tags: '',
    ExperimentConfig: {ExperimentName: '', TrialName: '', TrialComponentDisplayName: '', RunName: ''}
  },
  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=SageMaker.CreateTransformJob');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TransformJobName: '',
  ModelName: '',
  MaxConcurrentTransforms: '',
  ModelClientConfig: '',
  MaxPayloadInMB: '',
  BatchStrategy: '',
  Environment: '',
  TransformInput: '',
  TransformOutput: '',
  DataCaptureConfig: '',
  TransformResources: '',
  DataProcessing: '',
  Tags: '',
  ExperimentConfig: {
    ExperimentName: '',
    TrialName: '',
    TrialComponentDisplayName: '',
    RunName: ''
  }
});

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=SageMaker.CreateTransformJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TransformJobName: '',
    ModelName: '',
    MaxConcurrentTransforms: '',
    ModelClientConfig: '',
    MaxPayloadInMB: '',
    BatchStrategy: '',
    Environment: '',
    TransformInput: '',
    TransformOutput: '',
    DataCaptureConfig: '',
    TransformResources: '',
    DataProcessing: '',
    Tags: '',
    ExperimentConfig: {ExperimentName: '', TrialName: '', TrialComponentDisplayName: '', RunName: ''}
  }
};

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=SageMaker.CreateTransformJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TransformJobName":"","ModelName":"","MaxConcurrentTransforms":"","ModelClientConfig":"","MaxPayloadInMB":"","BatchStrategy":"","Environment":"","TransformInput":"","TransformOutput":"","DataCaptureConfig":"","TransformResources":"","DataProcessing":"","Tags":"","ExperimentConfig":{"ExperimentName":"","TrialName":"","TrialComponentDisplayName":"","RunName":""}}'
};

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 = @{ @"TransformJobName": @"",
                              @"ModelName": @"",
                              @"MaxConcurrentTransforms": @"",
                              @"ModelClientConfig": @"",
                              @"MaxPayloadInMB": @"",
                              @"BatchStrategy": @"",
                              @"Environment": @"",
                              @"TransformInput": @"",
                              @"TransformOutput": @"",
                              @"DataCaptureConfig": @"",
                              @"TransformResources": @"",
                              @"DataProcessing": @"",
                              @"Tags": @"",
                              @"ExperimentConfig": @{ @"ExperimentName": @"", @"TrialName": @"", @"TrialComponentDisplayName": @"", @"RunName": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTransformJob"]
                                                       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=SageMaker.CreateTransformJob" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TransformJobName\": \"\",\n  \"ModelName\": \"\",\n  \"MaxConcurrentTransforms\": \"\",\n  \"ModelClientConfig\": \"\",\n  \"MaxPayloadInMB\": \"\",\n  \"BatchStrategy\": \"\",\n  \"Environment\": \"\",\n  \"TransformInput\": \"\",\n  \"TransformOutput\": \"\",\n  \"DataCaptureConfig\": \"\",\n  \"TransformResources\": \"\",\n  \"DataProcessing\": \"\",\n  \"Tags\": \"\",\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTransformJob",
  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([
    'TransformJobName' => '',
    'ModelName' => '',
    'MaxConcurrentTransforms' => '',
    'ModelClientConfig' => '',
    'MaxPayloadInMB' => '',
    'BatchStrategy' => '',
    'Environment' => '',
    'TransformInput' => '',
    'TransformOutput' => '',
    'DataCaptureConfig' => '',
    'TransformResources' => '',
    'DataProcessing' => '',
    'Tags' => '',
    'ExperimentConfig' => [
        'ExperimentName' => '',
        'TrialName' => '',
        'TrialComponentDisplayName' => '',
        'RunName' => ''
    ]
  ]),
  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=SageMaker.CreateTransformJob', [
  'body' => '{
  "TransformJobName": "",
  "ModelName": "",
  "MaxConcurrentTransforms": "",
  "ModelClientConfig": "",
  "MaxPayloadInMB": "",
  "BatchStrategy": "",
  "Environment": "",
  "TransformInput": "",
  "TransformOutput": "",
  "DataCaptureConfig": "",
  "TransformResources": "",
  "DataProcessing": "",
  "Tags": "",
  "ExperimentConfig": {
    "ExperimentName": "",
    "TrialName": "",
    "TrialComponentDisplayName": "",
    "RunName": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTransformJob');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TransformJobName' => '',
  'ModelName' => '',
  'MaxConcurrentTransforms' => '',
  'ModelClientConfig' => '',
  'MaxPayloadInMB' => '',
  'BatchStrategy' => '',
  'Environment' => '',
  'TransformInput' => '',
  'TransformOutput' => '',
  'DataCaptureConfig' => '',
  'TransformResources' => '',
  'DataProcessing' => '',
  'Tags' => '',
  'ExperimentConfig' => [
    'ExperimentName' => '',
    'TrialName' => '',
    'TrialComponentDisplayName' => '',
    'RunName' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TransformJobName' => '',
  'ModelName' => '',
  'MaxConcurrentTransforms' => '',
  'ModelClientConfig' => '',
  'MaxPayloadInMB' => '',
  'BatchStrategy' => '',
  'Environment' => '',
  'TransformInput' => '',
  'TransformOutput' => '',
  'DataCaptureConfig' => '',
  'TransformResources' => '',
  'DataProcessing' => '',
  'Tags' => '',
  'ExperimentConfig' => [
    'ExperimentName' => '',
    'TrialName' => '',
    'TrialComponentDisplayName' => '',
    'RunName' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTransformJob');
$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=SageMaker.CreateTransformJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TransformJobName": "",
  "ModelName": "",
  "MaxConcurrentTransforms": "",
  "ModelClientConfig": "",
  "MaxPayloadInMB": "",
  "BatchStrategy": "",
  "Environment": "",
  "TransformInput": "",
  "TransformOutput": "",
  "DataCaptureConfig": "",
  "TransformResources": "",
  "DataProcessing": "",
  "Tags": "",
  "ExperimentConfig": {
    "ExperimentName": "",
    "TrialName": "",
    "TrialComponentDisplayName": "",
    "RunName": ""
  }
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SageMaker.CreateTransformJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TransformJobName": "",
  "ModelName": "",
  "MaxConcurrentTransforms": "",
  "ModelClientConfig": "",
  "MaxPayloadInMB": "",
  "BatchStrategy": "",
  "Environment": "",
  "TransformInput": "",
  "TransformOutput": "",
  "DataCaptureConfig": "",
  "TransformResources": "",
  "DataProcessing": "",
  "Tags": "",
  "ExperimentConfig": {
    "ExperimentName": "",
    "TrialName": "",
    "TrialComponentDisplayName": "",
    "RunName": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TransformJobName\": \"\",\n  \"ModelName\": \"\",\n  \"MaxConcurrentTransforms\": \"\",\n  \"ModelClientConfig\": \"\",\n  \"MaxPayloadInMB\": \"\",\n  \"BatchStrategy\": \"\",\n  \"Environment\": \"\",\n  \"TransformInput\": \"\",\n  \"TransformOutput\": \"\",\n  \"DataCaptureConfig\": \"\",\n  \"TransformResources\": \"\",\n  \"DataProcessing\": \"\",\n  \"Tags\": \"\",\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  }\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=SageMaker.CreateTransformJob"

payload = {
    "TransformJobName": "",
    "ModelName": "",
    "MaxConcurrentTransforms": "",
    "ModelClientConfig": "",
    "MaxPayloadInMB": "",
    "BatchStrategy": "",
    "Environment": "",
    "TransformInput": "",
    "TransformOutput": "",
    "DataCaptureConfig": "",
    "TransformResources": "",
    "DataProcessing": "",
    "Tags": "",
    "ExperimentConfig": {
        "ExperimentName": "",
        "TrialName": "",
        "TrialComponentDisplayName": "",
        "RunName": ""
    }
}
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=SageMaker.CreateTransformJob"

payload <- "{\n  \"TransformJobName\": \"\",\n  \"ModelName\": \"\",\n  \"MaxConcurrentTransforms\": \"\",\n  \"ModelClientConfig\": \"\",\n  \"MaxPayloadInMB\": \"\",\n  \"BatchStrategy\": \"\",\n  \"Environment\": \"\",\n  \"TransformInput\": \"\",\n  \"TransformOutput\": \"\",\n  \"DataCaptureConfig\": \"\",\n  \"TransformResources\": \"\",\n  \"DataProcessing\": \"\",\n  \"Tags\": \"\",\n  \"ExperimentConfig\": {\n    \"ExperimentName\": \"\",\n    \"TrialName\": \"\",\n    \"TrialComponentDisplayName\": \"\",\n    \"RunName\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")