Amazon QuickSight

DELETE CancelIngestion

{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId

QUERY PARAMS

AwsAccountId

DataSetId

IngestionId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId"

	req, _ := http.NewRequest("DELETE", url, nil)

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

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

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

}

DELETE /baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId'
};

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId'
};

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

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId" in

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

 "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId")

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

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

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId

http DELETE {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

POST CreateAccountCustomization

{{baseUrl}}/accounts/:AwsAccountId/customizations

QUERY PARAMS

AwsAccountId

BODY json

{
  "AccountCustomization": {
    "DefaultTheme": "",
    "DefaultEmailCustomizationTemplate": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/customizations");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/accounts/:AwsAccountId/customizations" {:content-type :json
                                                                                  :form-params {:AccountCustomization {:DefaultTheme ""
                                                                                                                       :DefaultEmailCustomizationTemplate ""}
                                                                                                :Tags [{:Key ""
                                                                                                        :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/customizations"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/accounts/:AwsAccountId/customizations"),
    Content = new StringContent("{\n  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/accounts/:AwsAccountId/customizations");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/customizations"

	payload := strings.NewReader("{\n  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

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

	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/accounts/:AwsAccountId/customizations HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 167

{
  "AccountCustomization": {
    "DefaultTheme": "",
    "DefaultEmailCustomizationTemplate": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:AwsAccountId/customizations")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/customizations"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/customizations")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:AwsAccountId/customizations")
  .header("content-type", "application/json")
  .body("{\n  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  AccountCustomization: {
    DefaultTheme: '',
    DefaultEmailCustomizationTemplate: ''
  },
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/accounts/:AwsAccountId/customizations');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/customizations',
  headers: {'content-type': 'application/json'},
  data: {
    AccountCustomization: {DefaultTheme: '', DefaultEmailCustomizationTemplate: ''},
    Tags: [{Key: '', Value: ''}]
  }
};

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/customizations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"AccountCustomization":{"DefaultTheme":"","DefaultEmailCustomizationTemplate":""},"Tags":[{"Key":"","Value":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/customizations',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AccountCustomization": {\n    "DefaultTheme": "",\n    "DefaultEmailCustomizationTemplate": ""\n  },\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\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  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/customizations")
  .post(body)
  .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/accounts/:AwsAccountId/customizations',
  headers: {
    '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({
  AccountCustomization: {DefaultTheme: '', DefaultEmailCustomizationTemplate: ''},
  Tags: [{Key: '', Value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/customizations',
  headers: {'content-type': 'application/json'},
  body: {
    AccountCustomization: {DefaultTheme: '', DefaultEmailCustomizationTemplate: ''},
    Tags: [{Key: '', Value: ''}]
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/accounts/:AwsAccountId/customizations');

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

req.type('json');
req.send({
  AccountCustomization: {
    DefaultTheme: '',
    DefaultEmailCustomizationTemplate: ''
  },
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/customizations',
  headers: {'content-type': 'application/json'},
  data: {
    AccountCustomization: {DefaultTheme: '', DefaultEmailCustomizationTemplate: ''},
    Tags: [{Key: '', Value: ''}]
  }
};

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

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/customizations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"AccountCustomization":{"DefaultTheme":"","DefaultEmailCustomizationTemplate":""},"Tags":[{"Key":"","Value":""}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AccountCustomization": @{ @"DefaultTheme": @"", @"DefaultEmailCustomizationTemplate": @"" },
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/customizations"]
                                                       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}}/accounts/:AwsAccountId/customizations" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/accounts/:AwsAccountId/customizations",
  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([
    'AccountCustomization' => [
        'DefaultTheme' => '',
        'DefaultEmailCustomizationTemplate' => ''
    ],
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/accounts/:AwsAccountId/customizations', [
  'body' => '{
  "AccountCustomization": {
    "DefaultTheme": "",
    "DefaultEmailCustomizationTemplate": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/customizations');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AccountCustomization' => [
    'DefaultTheme' => '',
    'DefaultEmailCustomizationTemplate' => ''
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'AccountCustomization' => [
    'DefaultTheme' => '',
    'DefaultEmailCustomizationTemplate' => ''
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/customizations');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/customizations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccountCustomization": {
    "DefaultTheme": "",
    "DefaultEmailCustomizationTemplate": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/customizations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccountCustomization": {
    "DefaultTheme": "",
    "DefaultEmailCustomizationTemplate": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/accounts/:AwsAccountId/customizations", payload, headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/customizations"

payload = {
    "AccountCustomization": {
        "DefaultTheme": "",
        "DefaultEmailCustomizationTemplate": ""
    },
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/customizations"

payload <- "{\n  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/customizations")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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/accounts/:AwsAccountId/customizations') do |req|
  req.body = "{\n  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/customizations";

    let payload = json!({
        "AccountCustomization": json!({
            "DefaultTheme": "",
            "DefaultEmailCustomizationTemplate": ""
        }),
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/accounts/:AwsAccountId/customizations \
  --header 'content-type: application/json' \
  --data '{
  "AccountCustomization": {
    "DefaultTheme": "",
    "DefaultEmailCustomizationTemplate": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

echo '{
  "AccountCustomization": {
    "DefaultTheme": "",
    "DefaultEmailCustomizationTemplate": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/accounts/:AwsAccountId/customizations \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "AccountCustomization": {\n    "DefaultTheme": "",\n    "DefaultEmailCustomizationTemplate": ""\n  },\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/customizations

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "AccountCustomization": [
    "DefaultTheme": "",
    "DefaultEmailCustomizationTemplate": ""
  ],
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/customizations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

POST CreateAccountSubscription

{{baseUrl}}/account/:AwsAccountId

QUERY PARAMS

AwsAccountId

BODY json

{
  "Edition": "",
  "AuthenticationMethod": "",
  "AccountName": "",
  "NotificationEmail": "",
  "ActiveDirectoryName": "",
  "Realm": "",
  "DirectoryId": "",
  "AdminGroup": [],
  "AuthorGroup": [],
  "ReaderGroup": [],
  "FirstName": "",
  "LastName": "",
  "EmailAddress": "",
  "ContactNumber": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/:AwsAccountId");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Edition\": \"\",\n  \"AuthenticationMethod\": \"\",\n  \"AccountName\": \"\",\n  \"NotificationEmail\": \"\",\n  \"ActiveDirectoryName\": \"\",\n  \"Realm\": \"\",\n  \"DirectoryId\": \"\",\n  \"AdminGroup\": [],\n  \"AuthorGroup\": [],\n  \"ReaderGroup\": [],\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"EmailAddress\": \"\",\n  \"ContactNumber\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/account/:AwsAccountId" {:content-type :json
                                                                  :form-params {:Edition ""
                                                                                :AuthenticationMethod ""
                                                                                :AccountName ""
                                                                                :NotificationEmail ""
                                                                                :ActiveDirectoryName ""
                                                                                :Realm ""
                                                                                :DirectoryId ""
                                                                                :AdminGroup []
                                                                                :AuthorGroup []
                                                                                :ReaderGroup []
                                                                                :FirstName ""
                                                                                :LastName ""
                                                                                :EmailAddress ""
                                                                                :ContactNumber ""}})

require "http/client"

url = "{{baseUrl}}/account/:AwsAccountId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Edition\": \"\",\n  \"AuthenticationMethod\": \"\",\n  \"AccountName\": \"\",\n  \"NotificationEmail\": \"\",\n  \"ActiveDirectoryName\": \"\",\n  \"Realm\": \"\",\n  \"DirectoryId\": \"\",\n  \"AdminGroup\": [],\n  \"AuthorGroup\": [],\n  \"ReaderGroup\": [],\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"EmailAddress\": \"\",\n  \"ContactNumber\": \"\"\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}}/account/:AwsAccountId"),
    Content = new StringContent("{\n  \"Edition\": \"\",\n  \"AuthenticationMethod\": \"\",\n  \"AccountName\": \"\",\n  \"NotificationEmail\": \"\",\n  \"ActiveDirectoryName\": \"\",\n  \"Realm\": \"\",\n  \"DirectoryId\": \"\",\n  \"AdminGroup\": [],\n  \"AuthorGroup\": [],\n  \"ReaderGroup\": [],\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"EmailAddress\": \"\",\n  \"ContactNumber\": \"\"\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}}/account/:AwsAccountId");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Edition\": \"\",\n  \"AuthenticationMethod\": \"\",\n  \"AccountName\": \"\",\n  \"NotificationEmail\": \"\",\n  \"ActiveDirectoryName\": \"\",\n  \"Realm\": \"\",\n  \"DirectoryId\": \"\",\n  \"AdminGroup\": [],\n  \"AuthorGroup\": [],\n  \"ReaderGroup\": [],\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"EmailAddress\": \"\",\n  \"ContactNumber\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/:AwsAccountId"

	payload := strings.NewReader("{\n  \"Edition\": \"\",\n  \"AuthenticationMethod\": \"\",\n  \"AccountName\": \"\",\n  \"NotificationEmail\": \"\",\n  \"ActiveDirectoryName\": \"\",\n  \"Realm\": \"\",\n  \"DirectoryId\": \"\",\n  \"AdminGroup\": [],\n  \"AuthorGroup\": [],\n  \"ReaderGroup\": [],\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"EmailAddress\": \"\",\n  \"ContactNumber\": \"\"\n}")

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

	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/account/:AwsAccountId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 306

{
  "Edition": "",
  "AuthenticationMethod": "",
  "AccountName": "",
  "NotificationEmail": "",
  "ActiveDirectoryName": "",
  "Realm": "",
  "DirectoryId": "",
  "AdminGroup": [],
  "AuthorGroup": [],
  "ReaderGroup": [],
  "FirstName": "",
  "LastName": "",
  "EmailAddress": "",
  "ContactNumber": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/:AwsAccountId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Edition\": \"\",\n  \"AuthenticationMethod\": \"\",\n  \"AccountName\": \"\",\n  \"NotificationEmail\": \"\",\n  \"ActiveDirectoryName\": \"\",\n  \"Realm\": \"\",\n  \"DirectoryId\": \"\",\n  \"AdminGroup\": [],\n  \"AuthorGroup\": [],\n  \"ReaderGroup\": [],\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"EmailAddress\": \"\",\n  \"ContactNumber\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/:AwsAccountId"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Edition\": \"\",\n  \"AuthenticationMethod\": \"\",\n  \"AccountName\": \"\",\n  \"NotificationEmail\": \"\",\n  \"ActiveDirectoryName\": \"\",\n  \"Realm\": \"\",\n  \"DirectoryId\": \"\",\n  \"AdminGroup\": [],\n  \"AuthorGroup\": [],\n  \"ReaderGroup\": [],\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"EmailAddress\": \"\",\n  \"ContactNumber\": \"\"\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  \"Edition\": \"\",\n  \"AuthenticationMethod\": \"\",\n  \"AccountName\": \"\",\n  \"NotificationEmail\": \"\",\n  \"ActiveDirectoryName\": \"\",\n  \"Realm\": \"\",\n  \"DirectoryId\": \"\",\n  \"AdminGroup\": [],\n  \"AuthorGroup\": [],\n  \"ReaderGroup\": [],\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"EmailAddress\": \"\",\n  \"ContactNumber\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/:AwsAccountId")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/account/:AwsAccountId")
  .header("content-type", "application/json")
  .body("{\n  \"Edition\": \"\",\n  \"AuthenticationMethod\": \"\",\n  \"AccountName\": \"\",\n  \"NotificationEmail\": \"\",\n  \"ActiveDirectoryName\": \"\",\n  \"Realm\": \"\",\n  \"DirectoryId\": \"\",\n  \"AdminGroup\": [],\n  \"AuthorGroup\": [],\n  \"ReaderGroup\": [],\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"EmailAddress\": \"\",\n  \"ContactNumber\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Edition: '',
  AuthenticationMethod: '',
  AccountName: '',
  NotificationEmail: '',
  ActiveDirectoryName: '',
  Realm: '',
  DirectoryId: '',
  AdminGroup: [],
  AuthorGroup: [],
  ReaderGroup: [],
  FirstName: '',
  LastName: '',
  EmailAddress: '',
  ContactNumber: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/account/:AwsAccountId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/:AwsAccountId',
  headers: {'content-type': 'application/json'},
  data: {
    Edition: '',
    AuthenticationMethod: '',
    AccountName: '',
    NotificationEmail: '',
    ActiveDirectoryName: '',
    Realm: '',
    DirectoryId: '',
    AdminGroup: [],
    AuthorGroup: [],
    ReaderGroup: [],
    FirstName: '',
    LastName: '',
    EmailAddress: '',
    ContactNumber: ''
  }
};

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

const url = '{{baseUrl}}/account/:AwsAccountId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Edition":"","AuthenticationMethod":"","AccountName":"","NotificationEmail":"","ActiveDirectoryName":"","Realm":"","DirectoryId":"","AdminGroup":[],"AuthorGroup":[],"ReaderGroup":[],"FirstName":"","LastName":"","EmailAddress":"","ContactNumber":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/:AwsAccountId',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Edition": "",\n  "AuthenticationMethod": "",\n  "AccountName": "",\n  "NotificationEmail": "",\n  "ActiveDirectoryName": "",\n  "Realm": "",\n  "DirectoryId": "",\n  "AdminGroup": [],\n  "AuthorGroup": [],\n  "ReaderGroup": [],\n  "FirstName": "",\n  "LastName": "",\n  "EmailAddress": "",\n  "ContactNumber": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Edition\": \"\",\n  \"AuthenticationMethod\": \"\",\n  \"AccountName\": \"\",\n  \"NotificationEmail\": \"\",\n  \"ActiveDirectoryName\": \"\",\n  \"Realm\": \"\",\n  \"DirectoryId\": \"\",\n  \"AdminGroup\": [],\n  \"AuthorGroup\": [],\n  \"ReaderGroup\": [],\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"EmailAddress\": \"\",\n  \"ContactNumber\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/:AwsAccountId")
  .post(body)
  .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/account/:AwsAccountId',
  headers: {
    '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({
  Edition: '',
  AuthenticationMethod: '',
  AccountName: '',
  NotificationEmail: '',
  ActiveDirectoryName: '',
  Realm: '',
  DirectoryId: '',
  AdminGroup: [],
  AuthorGroup: [],
  ReaderGroup: [],
  FirstName: '',
  LastName: '',
  EmailAddress: '',
  ContactNumber: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/:AwsAccountId',
  headers: {'content-type': 'application/json'},
  body: {
    Edition: '',
    AuthenticationMethod: '',
    AccountName: '',
    NotificationEmail: '',
    ActiveDirectoryName: '',
    Realm: '',
    DirectoryId: '',
    AdminGroup: [],
    AuthorGroup: [],
    ReaderGroup: [],
    FirstName: '',
    LastName: '',
    EmailAddress: '',
    ContactNumber: ''
  },
  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}}/account/:AwsAccountId');

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

req.type('json');
req.send({
  Edition: '',
  AuthenticationMethod: '',
  AccountName: '',
  NotificationEmail: '',
  ActiveDirectoryName: '',
  Realm: '',
  DirectoryId: '',
  AdminGroup: [],
  AuthorGroup: [],
  ReaderGroup: [],
  FirstName: '',
  LastName: '',
  EmailAddress: '',
  ContactNumber: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/:AwsAccountId',
  headers: {'content-type': 'application/json'},
  data: {
    Edition: '',
    AuthenticationMethod: '',
    AccountName: '',
    NotificationEmail: '',
    ActiveDirectoryName: '',
    Realm: '',
    DirectoryId: '',
    AdminGroup: [],
    AuthorGroup: [],
    ReaderGroup: [],
    FirstName: '',
    LastName: '',
    EmailAddress: '',
    ContactNumber: ''
  }
};

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

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

const url = '{{baseUrl}}/account/:AwsAccountId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Edition":"","AuthenticationMethod":"","AccountName":"","NotificationEmail":"","ActiveDirectoryName":"","Realm":"","DirectoryId":"","AdminGroup":[],"AuthorGroup":[],"ReaderGroup":[],"FirstName":"","LastName":"","EmailAddress":"","ContactNumber":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Edition": @"",
                              @"AuthenticationMethod": @"",
                              @"AccountName": @"",
                              @"NotificationEmail": @"",
                              @"ActiveDirectoryName": @"",
                              @"Realm": @"",
                              @"DirectoryId": @"",
                              @"AdminGroup": @[  ],
                              @"AuthorGroup": @[  ],
                              @"ReaderGroup": @[  ],
                              @"FirstName": @"",
                              @"LastName": @"",
                              @"EmailAddress": @"",
                              @"ContactNumber": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/:AwsAccountId"]
                                                       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}}/account/:AwsAccountId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Edition\": \"\",\n  \"AuthenticationMethod\": \"\",\n  \"AccountName\": \"\",\n  \"NotificationEmail\": \"\",\n  \"ActiveDirectoryName\": \"\",\n  \"Realm\": \"\",\n  \"DirectoryId\": \"\",\n  \"AdminGroup\": [],\n  \"AuthorGroup\": [],\n  \"ReaderGroup\": [],\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"EmailAddress\": \"\",\n  \"ContactNumber\": \"\"\n}" in

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

 "{{baseUrl}}/account/:AwsAccountId",
  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([
    'Edition' => '',
    'AuthenticationMethod' => '',
    'AccountName' => '',
    'NotificationEmail' => '',
    'ActiveDirectoryName' => '',
    'Realm' => '',
    'DirectoryId' => '',
    'AdminGroup' => [
        
    ],
    'AuthorGroup' => [
        
    ],
    'ReaderGroup' => [
        
    ],
    'FirstName' => '',
    'LastName' => '',
    'EmailAddress' => '',
    'ContactNumber' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/account/:AwsAccountId', [
  'body' => '{
  "Edition": "",
  "AuthenticationMethod": "",
  "AccountName": "",
  "NotificationEmail": "",
  "ActiveDirectoryName": "",
  "Realm": "",
  "DirectoryId": "",
  "AdminGroup": [],
  "AuthorGroup": [],
  "ReaderGroup": [],
  "FirstName": "",
  "LastName": "",
  "EmailAddress": "",
  "ContactNumber": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/:AwsAccountId');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Edition' => '',
  'AuthenticationMethod' => '',
  'AccountName' => '',
  'NotificationEmail' => '',
  'ActiveDirectoryName' => '',
  'Realm' => '',
  'DirectoryId' => '',
  'AdminGroup' => [
    
  ],
  'AuthorGroup' => [
    
  ],
  'ReaderGroup' => [
    
  ],
  'FirstName' => '',
  'LastName' => '',
  'EmailAddress' => '',
  'ContactNumber' => ''
]));

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

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

append(json_encode([
  'Edition' => '',
  'AuthenticationMethod' => '',
  'AccountName' => '',
  'NotificationEmail' => '',
  'ActiveDirectoryName' => '',
  'Realm' => '',
  'DirectoryId' => '',
  'AdminGroup' => [
    
  ],
  'AuthorGroup' => [
    
  ],
  'ReaderGroup' => [
    
  ],
  'FirstName' => '',
  'LastName' => '',
  'EmailAddress' => '',
  'ContactNumber' => ''
]));
$request->setRequestUrl('{{baseUrl}}/account/:AwsAccountId');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/:AwsAccountId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Edition": "",
  "AuthenticationMethod": "",
  "AccountName": "",
  "NotificationEmail": "",
  "ActiveDirectoryName": "",
  "Realm": "",
  "DirectoryId": "",
  "AdminGroup": [],
  "AuthorGroup": [],
  "ReaderGroup": [],
  "FirstName": "",
  "LastName": "",
  "EmailAddress": "",
  "ContactNumber": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/:AwsAccountId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Edition": "",
  "AuthenticationMethod": "",
  "AccountName": "",
  "NotificationEmail": "",
  "ActiveDirectoryName": "",
  "Realm": "",
  "DirectoryId": "",
  "AdminGroup": [],
  "AuthorGroup": [],
  "ReaderGroup": [],
  "FirstName": "",
  "LastName": "",
  "EmailAddress": "",
  "ContactNumber": ""
}'

import http.client

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

payload = "{\n  \"Edition\": \"\",\n  \"AuthenticationMethod\": \"\",\n  \"AccountName\": \"\",\n  \"NotificationEmail\": \"\",\n  \"ActiveDirectoryName\": \"\",\n  \"Realm\": \"\",\n  \"DirectoryId\": \"\",\n  \"AdminGroup\": [],\n  \"AuthorGroup\": [],\n  \"ReaderGroup\": [],\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"EmailAddress\": \"\",\n  \"ContactNumber\": \"\"\n}"

headers = { 'content-type': "application/json" }

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

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

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

import requests

url = "{{baseUrl}}/account/:AwsAccountId"

payload = {
    "Edition": "",
    "AuthenticationMethod": "",
    "AccountName": "",
    "NotificationEmail": "",
    "ActiveDirectoryName": "",
    "Realm": "",
    "DirectoryId": "",
    "AdminGroup": [],
    "AuthorGroup": [],
    "ReaderGroup": [],
    "FirstName": "",
    "LastName": "",
    "EmailAddress": "",
    "ContactNumber": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/:AwsAccountId"

payload <- "{\n  \"Edition\": \"\",\n  \"AuthenticationMethod\": \"\",\n  \"AccountName\": \"\",\n  \"NotificationEmail\": \"\",\n  \"ActiveDirectoryName\": \"\",\n  \"Realm\": \"\",\n  \"DirectoryId\": \"\",\n  \"AdminGroup\": [],\n  \"AuthorGroup\": [],\n  \"ReaderGroup\": [],\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"EmailAddress\": \"\",\n  \"ContactNumber\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/:AwsAccountId")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Edition\": \"\",\n  \"AuthenticationMethod\": \"\",\n  \"AccountName\": \"\",\n  \"NotificationEmail\": \"\",\n  \"ActiveDirectoryName\": \"\",\n  \"Realm\": \"\",\n  \"DirectoryId\": \"\",\n  \"AdminGroup\": [],\n  \"AuthorGroup\": [],\n  \"ReaderGroup\": [],\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"EmailAddress\": \"\",\n  \"ContactNumber\": \"\"\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/account/:AwsAccountId') do |req|
  req.body = "{\n  \"Edition\": \"\",\n  \"AuthenticationMethod\": \"\",\n  \"AccountName\": \"\",\n  \"NotificationEmail\": \"\",\n  \"ActiveDirectoryName\": \"\",\n  \"Realm\": \"\",\n  \"DirectoryId\": \"\",\n  \"AdminGroup\": [],\n  \"AuthorGroup\": [],\n  \"ReaderGroup\": [],\n  \"FirstName\": \"\",\n  \"LastName\": \"\",\n  \"EmailAddress\": \"\",\n  \"ContactNumber\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/:AwsAccountId";

    let payload = json!({
        "Edition": "",
        "AuthenticationMethod": "",
        "AccountName": "",
        "NotificationEmail": "",
        "ActiveDirectoryName": "",
        "Realm": "",
        "DirectoryId": "",
        "AdminGroup": (),
        "AuthorGroup": (),
        "ReaderGroup": (),
        "FirstName": "",
        "LastName": "",
        "EmailAddress": "",
        "ContactNumber": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/:AwsAccountId \
  --header 'content-type: application/json' \
  --data '{
  "Edition": "",
  "AuthenticationMethod": "",
  "AccountName": "",
  "NotificationEmail": "",
  "ActiveDirectoryName": "",
  "Realm": "",
  "DirectoryId": "",
  "AdminGroup": [],
  "AuthorGroup": [],
  "ReaderGroup": [],
  "FirstName": "",
  "LastName": "",
  "EmailAddress": "",
  "ContactNumber": ""
}'

echo '{
  "Edition": "",
  "AuthenticationMethod": "",
  "AccountName": "",
  "NotificationEmail": "",
  "ActiveDirectoryName": "",
  "Realm": "",
  "DirectoryId": "",
  "AdminGroup": [],
  "AuthorGroup": [],
  "ReaderGroup": [],
  "FirstName": "",
  "LastName": "",
  "EmailAddress": "",
  "ContactNumber": ""
}' |  \
  http POST {{baseUrl}}/account/:AwsAccountId \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Edition": "",\n  "AuthenticationMethod": "",\n  "AccountName": "",\n  "NotificationEmail": "",\n  "ActiveDirectoryName": "",\n  "Realm": "",\n  "DirectoryId": "",\n  "AdminGroup": [],\n  "AuthorGroup": [],\n  "ReaderGroup": [],\n  "FirstName": "",\n  "LastName": "",\n  "EmailAddress": "",\n  "ContactNumber": ""\n}' \
  --output-document \
  - {{baseUrl}}/account/:AwsAccountId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Edition": "",
  "AuthenticationMethod": "",
  "AccountName": "",
  "NotificationEmail": "",
  "ActiveDirectoryName": "",
  "Realm": "",
  "DirectoryId": "",
  "AdminGroup": [],
  "AuthorGroup": [],
  "ReaderGroup": [],
  "FirstName": "",
  "LastName": "",
  "EmailAddress": "",
  "ContactNumber": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/:AwsAccountId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

POST CreateAnalysis

{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId

QUERY PARAMS

AwsAccountId

AnalysisId

BODY json

{
  "Name": "",
  "Parameters": {
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  },
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "SourceEntity": {
    "SourceTemplate": ""
  },
  "ThemeArn": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "Definition": {
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId");

struct curl_slist *headers = NULL;
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  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId" {:content-type :json
                                                                                        :form-params {:Name ""
                                                                                                      :Parameters {:StringParameters ""
                                                                                                                   :IntegerParameters ""
                                                                                                                   :DecimalParameters ""
                                                                                                                   :DateTimeParameters ""}
                                                                                                      :Permissions [{:Principal ""
                                                                                                                     :Actions ""}]
                                                                                                      :SourceEntity {:SourceTemplate ""}
                                                                                                      :ThemeArn ""
                                                                                                      :Tags [{:Key ""
                                                                                                              :Value ""}]
                                                                                                      :Definition {:DataSetIdentifierDeclarations ""
                                                                                                                   :Sheets ""
                                                                                                                   :CalculatedFields ""
                                                                                                                   :ParameterDeclarations ""
                                                                                                                   :FilterGroups ""
                                                                                                                   :ColumnConfigurations ""
                                                                                                                   :AnalysisDefaults {:DefaultNewSheetConfiguration ""}}}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\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}}/accounts/:AwsAccountId/analyses/:AnalysisId"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\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}}/accounts/:AwsAccountId/analyses/:AnalysisId");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}")

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

	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/accounts/:AwsAccountId/analyses/:AnalysisId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 637

{
  "Name": "",
  "Parameters": {
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  },
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "SourceEntity": {
    "SourceTemplate": ""
  },
  "ThemeArn": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "Definition": {
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\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  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Parameters: {
    StringParameters: '',
    IntegerParameters: '',
    DecimalParameters: '',
    DateTimeParameters: ''
  },
  Permissions: [
    {
      Principal: '',
      Actions: ''
    }
  ],
  SourceEntity: {
    SourceTemplate: ''
  },
  ThemeArn: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  Definition: {
    DataSetIdentifierDeclarations: '',
    Sheets: '',
    CalculatedFields: '',
    ParameterDeclarations: '',
    FilterGroups: '',
    ColumnConfigurations: '',
    AnalysisDefaults: {
      DefaultNewSheetConfiguration: ''
    }
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Parameters: {
      StringParameters: '',
      IntegerParameters: '',
      DecimalParameters: '',
      DateTimeParameters: ''
    },
    Permissions: [{Principal: '', Actions: ''}],
    SourceEntity: {SourceTemplate: ''},
    ThemeArn: '',
    Tags: [{Key: '', Value: ''}],
    Definition: {
      DataSetIdentifierDeclarations: '',
      Sheets: '',
      CalculatedFields: '',
      ParameterDeclarations: '',
      FilterGroups: '',
      ColumnConfigurations: '',
      AnalysisDefaults: {DefaultNewSheetConfiguration: ''}
    }
  }
};

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Parameters":{"StringParameters":"","IntegerParameters":"","DecimalParameters":"","DateTimeParameters":""},"Permissions":[{"Principal":"","Actions":""}],"SourceEntity":{"SourceTemplate":""},"ThemeArn":"","Tags":[{"Key":"","Value":""}],"Definition":{"DataSetIdentifierDeclarations":"","Sheets":"","CalculatedFields":"","ParameterDeclarations":"","FilterGroups":"","ColumnConfigurations":"","AnalysisDefaults":{"DefaultNewSheetConfiguration":""}}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Parameters": {\n    "StringParameters": "",\n    "IntegerParameters": "",\n    "DecimalParameters": "",\n    "DateTimeParameters": ""\n  },\n  "Permissions": [\n    {\n      "Principal": "",\n      "Actions": ""\n    }\n  ],\n  "SourceEntity": {\n    "SourceTemplate": ""\n  },\n  "ThemeArn": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "Definition": {\n    "DataSetIdentifierDeclarations": "",\n    "Sheets": "",\n    "CalculatedFields": "",\n    "ParameterDeclarations": "",\n    "FilterGroups": "",\n    "ColumnConfigurations": "",\n    "AnalysisDefaults": {\n      "DefaultNewSheetConfiguration": ""\n    }\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  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId")
  .post(body)
  .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/accounts/:AwsAccountId/analyses/:AnalysisId',
  headers: {
    '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: '',
  Parameters: {
    StringParameters: '',
    IntegerParameters: '',
    DecimalParameters: '',
    DateTimeParameters: ''
  },
  Permissions: [{Principal: '', Actions: ''}],
  SourceEntity: {SourceTemplate: ''},
  ThemeArn: '',
  Tags: [{Key: '', Value: ''}],
  Definition: {
    DataSetIdentifierDeclarations: '',
    Sheets: '',
    CalculatedFields: '',
    ParameterDeclarations: '',
    FilterGroups: '',
    ColumnConfigurations: '',
    AnalysisDefaults: {DefaultNewSheetConfiguration: ''}
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId',
  headers: {'content-type': 'application/json'},
  body: {
    Name: '',
    Parameters: {
      StringParameters: '',
      IntegerParameters: '',
      DecimalParameters: '',
      DateTimeParameters: ''
    },
    Permissions: [{Principal: '', Actions: ''}],
    SourceEntity: {SourceTemplate: ''},
    ThemeArn: '',
    Tags: [{Key: '', Value: ''}],
    Definition: {
      DataSetIdentifierDeclarations: '',
      Sheets: '',
      CalculatedFields: '',
      ParameterDeclarations: '',
      FilterGroups: '',
      ColumnConfigurations: '',
      AnalysisDefaults: {DefaultNewSheetConfiguration: ''}
    }
  },
  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}}/accounts/:AwsAccountId/analyses/:AnalysisId');

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

req.type('json');
req.send({
  Name: '',
  Parameters: {
    StringParameters: '',
    IntegerParameters: '',
    DecimalParameters: '',
    DateTimeParameters: ''
  },
  Permissions: [
    {
      Principal: '',
      Actions: ''
    }
  ],
  SourceEntity: {
    SourceTemplate: ''
  },
  ThemeArn: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  Definition: {
    DataSetIdentifierDeclarations: '',
    Sheets: '',
    CalculatedFields: '',
    ParameterDeclarations: '',
    FilterGroups: '',
    ColumnConfigurations: '',
    AnalysisDefaults: {
      DefaultNewSheetConfiguration: ''
    }
  }
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Parameters: {
      StringParameters: '',
      IntegerParameters: '',
      DecimalParameters: '',
      DateTimeParameters: ''
    },
    Permissions: [{Principal: '', Actions: ''}],
    SourceEntity: {SourceTemplate: ''},
    ThemeArn: '',
    Tags: [{Key: '', Value: ''}],
    Definition: {
      DataSetIdentifierDeclarations: '',
      Sheets: '',
      CalculatedFields: '',
      ParameterDeclarations: '',
      FilterGroups: '',
      ColumnConfigurations: '',
      AnalysisDefaults: {DefaultNewSheetConfiguration: ''}
    }
  }
};

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

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Parameters":{"StringParameters":"","IntegerParameters":"","DecimalParameters":"","DateTimeParameters":""},"Permissions":[{"Principal":"","Actions":""}],"SourceEntity":{"SourceTemplate":""},"ThemeArn":"","Tags":[{"Key":"","Value":""}],"Definition":{"DataSetIdentifierDeclarations":"","Sheets":"","CalculatedFields":"","ParameterDeclarations":"","FilterGroups":"","ColumnConfigurations":"","AnalysisDefaults":{"DefaultNewSheetConfiguration":""}}}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"Parameters": @{ @"StringParameters": @"", @"IntegerParameters": @"", @"DecimalParameters": @"", @"DateTimeParameters": @"" },
                              @"Permissions": @[ @{ @"Principal": @"", @"Actions": @"" } ],
                              @"SourceEntity": @{ @"SourceTemplate": @"" },
                              @"ThemeArn": @"",
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"Definition": @{ @"DataSetIdentifierDeclarations": @"", @"Sheets": @"", @"CalculatedFields": @"", @"ParameterDeclarations": @"", @"FilterGroups": @"", @"ColumnConfigurations": @"", @"AnalysisDefaults": @{ @"DefaultNewSheetConfiguration": @"" } } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId"]
                                                       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}}/accounts/:AwsAccountId/analyses/:AnalysisId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}" in

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

 "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId",
  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' => '',
    'Parameters' => [
        'StringParameters' => '',
        'IntegerParameters' => '',
        'DecimalParameters' => '',
        'DateTimeParameters' => ''
    ],
    'Permissions' => [
        [
                'Principal' => '',
                'Actions' => ''
        ]
    ],
    'SourceEntity' => [
        'SourceTemplate' => ''
    ],
    'ThemeArn' => '',
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'Definition' => [
        'DataSetIdentifierDeclarations' => '',
        'Sheets' => '',
        'CalculatedFields' => '',
        'ParameterDeclarations' => '',
        'FilterGroups' => '',
        'ColumnConfigurations' => '',
        'AnalysisDefaults' => [
                'DefaultNewSheetConfiguration' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId', [
  'body' => '{
  "Name": "",
  "Parameters": {
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  },
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "SourceEntity": {
    "SourceTemplate": ""
  },
  "ThemeArn": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "Definition": {
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Parameters' => [
    'StringParameters' => '',
    'IntegerParameters' => '',
    'DecimalParameters' => '',
    'DateTimeParameters' => ''
  ],
  'Permissions' => [
    [
        'Principal' => '',
        'Actions' => ''
    ]
  ],
  'SourceEntity' => [
    'SourceTemplate' => ''
  ],
  'ThemeArn' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'Definition' => [
    'DataSetIdentifierDeclarations' => '',
    'Sheets' => '',
    'CalculatedFields' => '',
    'ParameterDeclarations' => '',
    'FilterGroups' => '',
    'ColumnConfigurations' => '',
    'AnalysisDefaults' => [
        'DefaultNewSheetConfiguration' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'Name' => '',
  'Parameters' => [
    'StringParameters' => '',
    'IntegerParameters' => '',
    'DecimalParameters' => '',
    'DateTimeParameters' => ''
  ],
  'Permissions' => [
    [
        'Principal' => '',
        'Actions' => ''
    ]
  ],
  'SourceEntity' => [
    'SourceTemplate' => ''
  ],
  'ThemeArn' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'Definition' => [
    'DataSetIdentifierDeclarations' => '',
    'Sheets' => '',
    'CalculatedFields' => '',
    'ParameterDeclarations' => '',
    'FilterGroups' => '',
    'ColumnConfigurations' => '',
    'AnalysisDefaults' => [
        'DefaultNewSheetConfiguration' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Parameters": {
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  },
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "SourceEntity": {
    "SourceTemplate": ""
  },
  "ThemeArn": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "Definition": {
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Parameters": {
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  },
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "SourceEntity": {
    "SourceTemplate": ""
  },
  "ThemeArn": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "Definition": {
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/accounts/:AwsAccountId/analyses/:AnalysisId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId"

payload = {
    "Name": "",
    "Parameters": {
        "StringParameters": "",
        "IntegerParameters": "",
        "DecimalParameters": "",
        "DateTimeParameters": ""
    },
    "Permissions": [
        {
            "Principal": "",
            "Actions": ""
        }
    ],
    "SourceEntity": { "SourceTemplate": "" },
    "ThemeArn": "",
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "Definition": {
        "DataSetIdentifierDeclarations": "",
        "Sheets": "",
        "CalculatedFields": "",
        "ParameterDeclarations": "",
        "FilterGroups": "",
        "ColumnConfigurations": "",
        "AnalysisDefaults": { "DefaultNewSheetConfiguration": "" }
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId"

payload <- "{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\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/accounts/:AwsAccountId/analyses/:AnalysisId') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId";

    let payload = json!({
        "Name": "",
        "Parameters": json!({
            "StringParameters": "",
            "IntegerParameters": "",
            "DecimalParameters": "",
            "DateTimeParameters": ""
        }),
        "Permissions": (
            json!({
                "Principal": "",
                "Actions": ""
            })
        ),
        "SourceEntity": json!({"SourceTemplate": ""}),
        "ThemeArn": "",
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "Definition": json!({
            "DataSetIdentifierDeclarations": "",
            "Sheets": "",
            "CalculatedFields": "",
            "ParameterDeclarations": "",
            "FilterGroups": "",
            "ColumnConfigurations": "",
            "AnalysisDefaults": json!({"DefaultNewSheetConfiguration": ""})
        })
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId \
  --header 'content-type: application/json' \
  --data '{
  "Name": "",
  "Parameters": {
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  },
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "SourceEntity": {
    "SourceTemplate": ""
  },
  "ThemeArn": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "Definition": {
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}'

echo '{
  "Name": "",
  "Parameters": {
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  },
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "SourceEntity": {
    "SourceTemplate": ""
  },
  "ThemeArn": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "Definition": {
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}' |  \
  http POST {{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Parameters": {\n    "StringParameters": "",\n    "IntegerParameters": "",\n    "DecimalParameters": "",\n    "DateTimeParameters": ""\n  },\n  "Permissions": [\n    {\n      "Principal": "",\n      "Actions": ""\n    }\n  ],\n  "SourceEntity": {\n    "SourceTemplate": ""\n  },\n  "ThemeArn": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "Definition": {\n    "DataSetIdentifierDeclarations": "",\n    "Sheets": "",\n    "CalculatedFields": "",\n    "ParameterDeclarations": "",\n    "FilterGroups": "",\n    "ColumnConfigurations": "",\n    "AnalysisDefaults": {\n      "DefaultNewSheetConfiguration": ""\n    }\n  }\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "Parameters": [
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  ],
  "Permissions": [
    [
      "Principal": "",
      "Actions": ""
    ]
  ],
  "SourceEntity": ["SourceTemplate": ""],
  "ThemeArn": "",
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "Definition": [
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": ["DefaultNewSheetConfiguration": ""]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

POST CreateDashboard

{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId

QUERY PARAMS

AwsAccountId

DashboardId

BODY json

{
  "Name": "",
  "Parameters": {
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  },
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "SourceEntity": {
    "SourceTemplate": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "VersionDescription": "",
  "DashboardPublishOptions": {
    "AdHocFilteringOption": "",
    "ExportToCSVOption": "",
    "SheetControlsOption": "",
    "VisualPublishOptions": "",
    "SheetLayoutElementMaximizationOption": "",
    "VisualMenuOption": "",
    "VisualAxisSortOption": "",
    "ExportWithHiddenFieldsOption": "",
    "DataPointDrillUpDownOption": "",
    "DataPointMenuLabelOption": "",
    "DataPointTooltipOption": ""
  },
  "ThemeArn": "",
  "Definition": {
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId");

struct curl_slist *headers = NULL;
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  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId" {:content-type :json
                                                                                           :form-params {:Name ""
                                                                                                         :Parameters {:StringParameters ""
                                                                                                                      :IntegerParameters ""
                                                                                                                      :DecimalParameters ""
                                                                                                                      :DateTimeParameters ""}
                                                                                                         :Permissions [{:Principal ""
                                                                                                                        :Actions ""}]
                                                                                                         :SourceEntity {:SourceTemplate ""}
                                                                                                         :Tags [{:Key ""
                                                                                                                 :Value ""}]
                                                                                                         :VersionDescription ""
                                                                                                         :DashboardPublishOptions {:AdHocFilteringOption ""
                                                                                                                                   :ExportToCSVOption ""
                                                                                                                                   :SheetControlsOption ""
                                                                                                                                   :VisualPublishOptions ""
                                                                                                                                   :SheetLayoutElementMaximizationOption ""
                                                                                                                                   :VisualMenuOption ""
                                                                                                                                   :VisualAxisSortOption ""
                                                                                                                                   :ExportWithHiddenFieldsOption ""
                                                                                                                                   :DataPointDrillUpDownOption ""
                                                                                                                                   :DataPointMenuLabelOption ""
                                                                                                                                   :DataPointTooltipOption ""}
                                                                                                         :ThemeArn ""
                                                                                                         :Definition {:DataSetIdentifierDeclarations ""
                                                                                                                      :Sheets ""
                                                                                                                      :CalculatedFields ""
                                                                                                                      :ParameterDeclarations ""
                                                                                                                      :FilterGroups ""
                                                                                                                      :ColumnConfigurations ""
                                                                                                                      :AnalysisDefaults {:DefaultNewSheetConfiguration ""}}}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\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}}/accounts/:AwsAccountId/dashboards/:DashboardId"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\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}}/accounts/:AwsAccountId/dashboards/:DashboardId");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}")

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

	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/accounts/:AwsAccountId/dashboards/:DashboardId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1080

{
  "Name": "",
  "Parameters": {
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  },
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "SourceEntity": {
    "SourceTemplate": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "VersionDescription": "",
  "DashboardPublishOptions": {
    "AdHocFilteringOption": "",
    "ExportToCSVOption": "",
    "SheetControlsOption": "",
    "VisualPublishOptions": "",
    "SheetLayoutElementMaximizationOption": "",
    "VisualMenuOption": "",
    "VisualAxisSortOption": "",
    "ExportWithHiddenFieldsOption": "",
    "DataPointDrillUpDownOption": "",
    "DataPointMenuLabelOption": "",
    "DataPointTooltipOption": ""
  },
  "ThemeArn": "",
  "Definition": {
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\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  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Parameters: {
    StringParameters: '',
    IntegerParameters: '',
    DecimalParameters: '',
    DateTimeParameters: ''
  },
  Permissions: [
    {
      Principal: '',
      Actions: ''
    }
  ],
  SourceEntity: {
    SourceTemplate: ''
  },
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  VersionDescription: '',
  DashboardPublishOptions: {
    AdHocFilteringOption: '',
    ExportToCSVOption: '',
    SheetControlsOption: '',
    VisualPublishOptions: '',
    SheetLayoutElementMaximizationOption: '',
    VisualMenuOption: '',
    VisualAxisSortOption: '',
    ExportWithHiddenFieldsOption: '',
    DataPointDrillUpDownOption: '',
    DataPointMenuLabelOption: '',
    DataPointTooltipOption: ''
  },
  ThemeArn: '',
  Definition: {
    DataSetIdentifierDeclarations: '',
    Sheets: '',
    CalculatedFields: '',
    ParameterDeclarations: '',
    FilterGroups: '',
    ColumnConfigurations: '',
    AnalysisDefaults: {
      DefaultNewSheetConfiguration: ''
    }
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Parameters: {
      StringParameters: '',
      IntegerParameters: '',
      DecimalParameters: '',
      DateTimeParameters: ''
    },
    Permissions: [{Principal: '', Actions: ''}],
    SourceEntity: {SourceTemplate: ''},
    Tags: [{Key: '', Value: ''}],
    VersionDescription: '',
    DashboardPublishOptions: {
      AdHocFilteringOption: '',
      ExportToCSVOption: '',
      SheetControlsOption: '',
      VisualPublishOptions: '',
      SheetLayoutElementMaximizationOption: '',
      VisualMenuOption: '',
      VisualAxisSortOption: '',
      ExportWithHiddenFieldsOption: '',
      DataPointDrillUpDownOption: '',
      DataPointMenuLabelOption: '',
      DataPointTooltipOption: ''
    },
    ThemeArn: '',
    Definition: {
      DataSetIdentifierDeclarations: '',
      Sheets: '',
      CalculatedFields: '',
      ParameterDeclarations: '',
      FilterGroups: '',
      ColumnConfigurations: '',
      AnalysisDefaults: {DefaultNewSheetConfiguration: ''}
    }
  }
};

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Parameters":{"StringParameters":"","IntegerParameters":"","DecimalParameters":"","DateTimeParameters":""},"Permissions":[{"Principal":"","Actions":""}],"SourceEntity":{"SourceTemplate":""},"Tags":[{"Key":"","Value":""}],"VersionDescription":"","DashboardPublishOptions":{"AdHocFilteringOption":"","ExportToCSVOption":"","SheetControlsOption":"","VisualPublishOptions":"","SheetLayoutElementMaximizationOption":"","VisualMenuOption":"","VisualAxisSortOption":"","ExportWithHiddenFieldsOption":"","DataPointDrillUpDownOption":"","DataPointMenuLabelOption":"","DataPointTooltipOption":""},"ThemeArn":"","Definition":{"DataSetIdentifierDeclarations":"","Sheets":"","CalculatedFields":"","ParameterDeclarations":"","FilterGroups":"","ColumnConfigurations":"","AnalysisDefaults":{"DefaultNewSheetConfiguration":""}}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Parameters": {\n    "StringParameters": "",\n    "IntegerParameters": "",\n    "DecimalParameters": "",\n    "DateTimeParameters": ""\n  },\n  "Permissions": [\n    {\n      "Principal": "",\n      "Actions": ""\n    }\n  ],\n  "SourceEntity": {\n    "SourceTemplate": ""\n  },\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "VersionDescription": "",\n  "DashboardPublishOptions": {\n    "AdHocFilteringOption": "",\n    "ExportToCSVOption": "",\n    "SheetControlsOption": "",\n    "VisualPublishOptions": "",\n    "SheetLayoutElementMaximizationOption": "",\n    "VisualMenuOption": "",\n    "VisualAxisSortOption": "",\n    "ExportWithHiddenFieldsOption": "",\n    "DataPointDrillUpDownOption": "",\n    "DataPointMenuLabelOption": "",\n    "DataPointTooltipOption": ""\n  },\n  "ThemeArn": "",\n  "Definition": {\n    "DataSetIdentifierDeclarations": "",\n    "Sheets": "",\n    "CalculatedFields": "",\n    "ParameterDeclarations": "",\n    "FilterGroups": "",\n    "ColumnConfigurations": "",\n    "AnalysisDefaults": {\n      "DefaultNewSheetConfiguration": ""\n    }\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  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId")
  .post(body)
  .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/accounts/:AwsAccountId/dashboards/:DashboardId',
  headers: {
    '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: '',
  Parameters: {
    StringParameters: '',
    IntegerParameters: '',
    DecimalParameters: '',
    DateTimeParameters: ''
  },
  Permissions: [{Principal: '', Actions: ''}],
  SourceEntity: {SourceTemplate: ''},
  Tags: [{Key: '', Value: ''}],
  VersionDescription: '',
  DashboardPublishOptions: {
    AdHocFilteringOption: '',
    ExportToCSVOption: '',
    SheetControlsOption: '',
    VisualPublishOptions: '',
    SheetLayoutElementMaximizationOption: '',
    VisualMenuOption: '',
    VisualAxisSortOption: '',
    ExportWithHiddenFieldsOption: '',
    DataPointDrillUpDownOption: '',
    DataPointMenuLabelOption: '',
    DataPointTooltipOption: ''
  },
  ThemeArn: '',
  Definition: {
    DataSetIdentifierDeclarations: '',
    Sheets: '',
    CalculatedFields: '',
    ParameterDeclarations: '',
    FilterGroups: '',
    ColumnConfigurations: '',
    AnalysisDefaults: {DefaultNewSheetConfiguration: ''}
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId',
  headers: {'content-type': 'application/json'},
  body: {
    Name: '',
    Parameters: {
      StringParameters: '',
      IntegerParameters: '',
      DecimalParameters: '',
      DateTimeParameters: ''
    },
    Permissions: [{Principal: '', Actions: ''}],
    SourceEntity: {SourceTemplate: ''},
    Tags: [{Key: '', Value: ''}],
    VersionDescription: '',
    DashboardPublishOptions: {
      AdHocFilteringOption: '',
      ExportToCSVOption: '',
      SheetControlsOption: '',
      VisualPublishOptions: '',
      SheetLayoutElementMaximizationOption: '',
      VisualMenuOption: '',
      VisualAxisSortOption: '',
      ExportWithHiddenFieldsOption: '',
      DataPointDrillUpDownOption: '',
      DataPointMenuLabelOption: '',
      DataPointTooltipOption: ''
    },
    ThemeArn: '',
    Definition: {
      DataSetIdentifierDeclarations: '',
      Sheets: '',
      CalculatedFields: '',
      ParameterDeclarations: '',
      FilterGroups: '',
      ColumnConfigurations: '',
      AnalysisDefaults: {DefaultNewSheetConfiguration: ''}
    }
  },
  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}}/accounts/:AwsAccountId/dashboards/:DashboardId');

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

req.type('json');
req.send({
  Name: '',
  Parameters: {
    StringParameters: '',
    IntegerParameters: '',
    DecimalParameters: '',
    DateTimeParameters: ''
  },
  Permissions: [
    {
      Principal: '',
      Actions: ''
    }
  ],
  SourceEntity: {
    SourceTemplate: ''
  },
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  VersionDescription: '',
  DashboardPublishOptions: {
    AdHocFilteringOption: '',
    ExportToCSVOption: '',
    SheetControlsOption: '',
    VisualPublishOptions: '',
    SheetLayoutElementMaximizationOption: '',
    VisualMenuOption: '',
    VisualAxisSortOption: '',
    ExportWithHiddenFieldsOption: '',
    DataPointDrillUpDownOption: '',
    DataPointMenuLabelOption: '',
    DataPointTooltipOption: ''
  },
  ThemeArn: '',
  Definition: {
    DataSetIdentifierDeclarations: '',
    Sheets: '',
    CalculatedFields: '',
    ParameterDeclarations: '',
    FilterGroups: '',
    ColumnConfigurations: '',
    AnalysisDefaults: {
      DefaultNewSheetConfiguration: ''
    }
  }
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Parameters: {
      StringParameters: '',
      IntegerParameters: '',
      DecimalParameters: '',
      DateTimeParameters: ''
    },
    Permissions: [{Principal: '', Actions: ''}],
    SourceEntity: {SourceTemplate: ''},
    Tags: [{Key: '', Value: ''}],
    VersionDescription: '',
    DashboardPublishOptions: {
      AdHocFilteringOption: '',
      ExportToCSVOption: '',
      SheetControlsOption: '',
      VisualPublishOptions: '',
      SheetLayoutElementMaximizationOption: '',
      VisualMenuOption: '',
      VisualAxisSortOption: '',
      ExportWithHiddenFieldsOption: '',
      DataPointDrillUpDownOption: '',
      DataPointMenuLabelOption: '',
      DataPointTooltipOption: ''
    },
    ThemeArn: '',
    Definition: {
      DataSetIdentifierDeclarations: '',
      Sheets: '',
      CalculatedFields: '',
      ParameterDeclarations: '',
      FilterGroups: '',
      ColumnConfigurations: '',
      AnalysisDefaults: {DefaultNewSheetConfiguration: ''}
    }
  }
};

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

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Parameters":{"StringParameters":"","IntegerParameters":"","DecimalParameters":"","DateTimeParameters":""},"Permissions":[{"Principal":"","Actions":""}],"SourceEntity":{"SourceTemplate":""},"Tags":[{"Key":"","Value":""}],"VersionDescription":"","DashboardPublishOptions":{"AdHocFilteringOption":"","ExportToCSVOption":"","SheetControlsOption":"","VisualPublishOptions":"","SheetLayoutElementMaximizationOption":"","VisualMenuOption":"","VisualAxisSortOption":"","ExportWithHiddenFieldsOption":"","DataPointDrillUpDownOption":"","DataPointMenuLabelOption":"","DataPointTooltipOption":""},"ThemeArn":"","Definition":{"DataSetIdentifierDeclarations":"","Sheets":"","CalculatedFields":"","ParameterDeclarations":"","FilterGroups":"","ColumnConfigurations":"","AnalysisDefaults":{"DefaultNewSheetConfiguration":""}}}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"Parameters": @{ @"StringParameters": @"", @"IntegerParameters": @"", @"DecimalParameters": @"", @"DateTimeParameters": @"" },
                              @"Permissions": @[ @{ @"Principal": @"", @"Actions": @"" } ],
                              @"SourceEntity": @{ @"SourceTemplate": @"" },
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"VersionDescription": @"",
                              @"DashboardPublishOptions": @{ @"AdHocFilteringOption": @"", @"ExportToCSVOption": @"", @"SheetControlsOption": @"", @"VisualPublishOptions": @"", @"SheetLayoutElementMaximizationOption": @"", @"VisualMenuOption": @"", @"VisualAxisSortOption": @"", @"ExportWithHiddenFieldsOption": @"", @"DataPointDrillUpDownOption": @"", @"DataPointMenuLabelOption": @"", @"DataPointTooltipOption": @"" },
                              @"ThemeArn": @"",
                              @"Definition": @{ @"DataSetIdentifierDeclarations": @"", @"Sheets": @"", @"CalculatedFields": @"", @"ParameterDeclarations": @"", @"FilterGroups": @"", @"ColumnConfigurations": @"", @"AnalysisDefaults": @{ @"DefaultNewSheetConfiguration": @"" } } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId"]
                                                       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}}/accounts/:AwsAccountId/dashboards/:DashboardId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}" in

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

 "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId",
  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' => '',
    'Parameters' => [
        'StringParameters' => '',
        'IntegerParameters' => '',
        'DecimalParameters' => '',
        'DateTimeParameters' => ''
    ],
    'Permissions' => [
        [
                'Principal' => '',
                'Actions' => ''
        ]
    ],
    'SourceEntity' => [
        'SourceTemplate' => ''
    ],
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'VersionDescription' => '',
    'DashboardPublishOptions' => [
        'AdHocFilteringOption' => '',
        'ExportToCSVOption' => '',
        'SheetControlsOption' => '',
        'VisualPublishOptions' => '',
        'SheetLayoutElementMaximizationOption' => '',
        'VisualMenuOption' => '',
        'VisualAxisSortOption' => '',
        'ExportWithHiddenFieldsOption' => '',
        'DataPointDrillUpDownOption' => '',
        'DataPointMenuLabelOption' => '',
        'DataPointTooltipOption' => ''
    ],
    'ThemeArn' => '',
    'Definition' => [
        'DataSetIdentifierDeclarations' => '',
        'Sheets' => '',
        'CalculatedFields' => '',
        'ParameterDeclarations' => '',
        'FilterGroups' => '',
        'ColumnConfigurations' => '',
        'AnalysisDefaults' => [
                'DefaultNewSheetConfiguration' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId', [
  'body' => '{
  "Name": "",
  "Parameters": {
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  },
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "SourceEntity": {
    "SourceTemplate": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "VersionDescription": "",
  "DashboardPublishOptions": {
    "AdHocFilteringOption": "",
    "ExportToCSVOption": "",
    "SheetControlsOption": "",
    "VisualPublishOptions": "",
    "SheetLayoutElementMaximizationOption": "",
    "VisualMenuOption": "",
    "VisualAxisSortOption": "",
    "ExportWithHiddenFieldsOption": "",
    "DataPointDrillUpDownOption": "",
    "DataPointMenuLabelOption": "",
    "DataPointTooltipOption": ""
  },
  "ThemeArn": "",
  "Definition": {
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Parameters' => [
    'StringParameters' => '',
    'IntegerParameters' => '',
    'DecimalParameters' => '',
    'DateTimeParameters' => ''
  ],
  'Permissions' => [
    [
        'Principal' => '',
        'Actions' => ''
    ]
  ],
  'SourceEntity' => [
    'SourceTemplate' => ''
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'VersionDescription' => '',
  'DashboardPublishOptions' => [
    'AdHocFilteringOption' => '',
    'ExportToCSVOption' => '',
    'SheetControlsOption' => '',
    'VisualPublishOptions' => '',
    'SheetLayoutElementMaximizationOption' => '',
    'VisualMenuOption' => '',
    'VisualAxisSortOption' => '',
    'ExportWithHiddenFieldsOption' => '',
    'DataPointDrillUpDownOption' => '',
    'DataPointMenuLabelOption' => '',
    'DataPointTooltipOption' => ''
  ],
  'ThemeArn' => '',
  'Definition' => [
    'DataSetIdentifierDeclarations' => '',
    'Sheets' => '',
    'CalculatedFields' => '',
    'ParameterDeclarations' => '',
    'FilterGroups' => '',
    'ColumnConfigurations' => '',
    'AnalysisDefaults' => [
        'DefaultNewSheetConfiguration' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'Name' => '',
  'Parameters' => [
    'StringParameters' => '',
    'IntegerParameters' => '',
    'DecimalParameters' => '',
    'DateTimeParameters' => ''
  ],
  'Permissions' => [
    [
        'Principal' => '',
        'Actions' => ''
    ]
  ],
  'SourceEntity' => [
    'SourceTemplate' => ''
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'VersionDescription' => '',
  'DashboardPublishOptions' => [
    'AdHocFilteringOption' => '',
    'ExportToCSVOption' => '',
    'SheetControlsOption' => '',
    'VisualPublishOptions' => '',
    'SheetLayoutElementMaximizationOption' => '',
    'VisualMenuOption' => '',
    'VisualAxisSortOption' => '',
    'ExportWithHiddenFieldsOption' => '',
    'DataPointDrillUpDownOption' => '',
    'DataPointMenuLabelOption' => '',
    'DataPointTooltipOption' => ''
  ],
  'ThemeArn' => '',
  'Definition' => [
    'DataSetIdentifierDeclarations' => '',
    'Sheets' => '',
    'CalculatedFields' => '',
    'ParameterDeclarations' => '',
    'FilterGroups' => '',
    'ColumnConfigurations' => '',
    'AnalysisDefaults' => [
        'DefaultNewSheetConfiguration' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Parameters": {
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  },
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "SourceEntity": {
    "SourceTemplate": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "VersionDescription": "",
  "DashboardPublishOptions": {
    "AdHocFilteringOption": "",
    "ExportToCSVOption": "",
    "SheetControlsOption": "",
    "VisualPublishOptions": "",
    "SheetLayoutElementMaximizationOption": "",
    "VisualMenuOption": "",
    "VisualAxisSortOption": "",
    "ExportWithHiddenFieldsOption": "",
    "DataPointDrillUpDownOption": "",
    "DataPointMenuLabelOption": "",
    "DataPointTooltipOption": ""
  },
  "ThemeArn": "",
  "Definition": {
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Parameters": {
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  },
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "SourceEntity": {
    "SourceTemplate": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "VersionDescription": "",
  "DashboardPublishOptions": {
    "AdHocFilteringOption": "",
    "ExportToCSVOption": "",
    "SheetControlsOption": "",
    "VisualPublishOptions": "",
    "SheetLayoutElementMaximizationOption": "",
    "VisualMenuOption": "",
    "VisualAxisSortOption": "",
    "ExportWithHiddenFieldsOption": "",
    "DataPointDrillUpDownOption": "",
    "DataPointMenuLabelOption": "",
    "DataPointTooltipOption": ""
  },
  "ThemeArn": "",
  "Definition": {
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId"

payload = {
    "Name": "",
    "Parameters": {
        "StringParameters": "",
        "IntegerParameters": "",
        "DecimalParameters": "",
        "DateTimeParameters": ""
    },
    "Permissions": [
        {
            "Principal": "",
            "Actions": ""
        }
    ],
    "SourceEntity": { "SourceTemplate": "" },
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "VersionDescription": "",
    "DashboardPublishOptions": {
        "AdHocFilteringOption": "",
        "ExportToCSVOption": "",
        "SheetControlsOption": "",
        "VisualPublishOptions": "",
        "SheetLayoutElementMaximizationOption": "",
        "VisualMenuOption": "",
        "VisualAxisSortOption": "",
        "ExportWithHiddenFieldsOption": "",
        "DataPointDrillUpDownOption": "",
        "DataPointMenuLabelOption": "",
        "DataPointTooltipOption": ""
    },
    "ThemeArn": "",
    "Definition": {
        "DataSetIdentifierDeclarations": "",
        "Sheets": "",
        "CalculatedFields": "",
        "ParameterDeclarations": "",
        "FilterGroups": "",
        "ColumnConfigurations": "",
        "AnalysisDefaults": { "DefaultNewSheetConfiguration": "" }
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId"

payload <- "{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\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/accounts/:AwsAccountId/dashboards/:DashboardId') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId";

    let payload = json!({
        "Name": "",
        "Parameters": json!({
            "StringParameters": "",
            "IntegerParameters": "",
            "DecimalParameters": "",
            "DateTimeParameters": ""
        }),
        "Permissions": (
            json!({
                "Principal": "",
                "Actions": ""
            })
        ),
        "SourceEntity": json!({"SourceTemplate": ""}),
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "VersionDescription": "",
        "DashboardPublishOptions": json!({
            "AdHocFilteringOption": "",
            "ExportToCSVOption": "",
            "SheetControlsOption": "",
            "VisualPublishOptions": "",
            "SheetLayoutElementMaximizationOption": "",
            "VisualMenuOption": "",
            "VisualAxisSortOption": "",
            "ExportWithHiddenFieldsOption": "",
            "DataPointDrillUpDownOption": "",
            "DataPointMenuLabelOption": "",
            "DataPointTooltipOption": ""
        }),
        "ThemeArn": "",
        "Definition": json!({
            "DataSetIdentifierDeclarations": "",
            "Sheets": "",
            "CalculatedFields": "",
            "ParameterDeclarations": "",
            "FilterGroups": "",
            "ColumnConfigurations": "",
            "AnalysisDefaults": json!({"DefaultNewSheetConfiguration": ""})
        })
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId \
  --header 'content-type: application/json' \
  --data '{
  "Name": "",
  "Parameters": {
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  },
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "SourceEntity": {
    "SourceTemplate": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "VersionDescription": "",
  "DashboardPublishOptions": {
    "AdHocFilteringOption": "",
    "ExportToCSVOption": "",
    "SheetControlsOption": "",
    "VisualPublishOptions": "",
    "SheetLayoutElementMaximizationOption": "",
    "VisualMenuOption": "",
    "VisualAxisSortOption": "",
    "ExportWithHiddenFieldsOption": "",
    "DataPointDrillUpDownOption": "",
    "DataPointMenuLabelOption": "",
    "DataPointTooltipOption": ""
  },
  "ThemeArn": "",
  "Definition": {
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}'

echo '{
  "Name": "",
  "Parameters": {
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  },
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "SourceEntity": {
    "SourceTemplate": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "VersionDescription": "",
  "DashboardPublishOptions": {
    "AdHocFilteringOption": "",
    "ExportToCSVOption": "",
    "SheetControlsOption": "",
    "VisualPublishOptions": "",
    "SheetLayoutElementMaximizationOption": "",
    "VisualMenuOption": "",
    "VisualAxisSortOption": "",
    "ExportWithHiddenFieldsOption": "",
    "DataPointDrillUpDownOption": "",
    "DataPointMenuLabelOption": "",
    "DataPointTooltipOption": ""
  },
  "ThemeArn": "",
  "Definition": {
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}' |  \
  http POST {{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Parameters": {\n    "StringParameters": "",\n    "IntegerParameters": "",\n    "DecimalParameters": "",\n    "DateTimeParameters": ""\n  },\n  "Permissions": [\n    {\n      "Principal": "",\n      "Actions": ""\n    }\n  ],\n  "SourceEntity": {\n    "SourceTemplate": ""\n  },\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "VersionDescription": "",\n  "DashboardPublishOptions": {\n    "AdHocFilteringOption": "",\n    "ExportToCSVOption": "",\n    "SheetControlsOption": "",\n    "VisualPublishOptions": "",\n    "SheetLayoutElementMaximizationOption": "",\n    "VisualMenuOption": "",\n    "VisualAxisSortOption": "",\n    "ExportWithHiddenFieldsOption": "",\n    "DataPointDrillUpDownOption": "",\n    "DataPointMenuLabelOption": "",\n    "DataPointTooltipOption": ""\n  },\n  "ThemeArn": "",\n  "Definition": {\n    "DataSetIdentifierDeclarations": "",\n    "Sheets": "",\n    "CalculatedFields": "",\n    "ParameterDeclarations": "",\n    "FilterGroups": "",\n    "ColumnConfigurations": "",\n    "AnalysisDefaults": {\n      "DefaultNewSheetConfiguration": ""\n    }\n  }\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "Parameters": [
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  ],
  "Permissions": [
    [
      "Principal": "",
      "Actions": ""
    ]
  ],
  "SourceEntity": ["SourceTemplate": ""],
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "VersionDescription": "",
  "DashboardPublishOptions": [
    "AdHocFilteringOption": "",
    "ExportToCSVOption": "",
    "SheetControlsOption": "",
    "VisualPublishOptions": "",
    "SheetLayoutElementMaximizationOption": "",
    "VisualMenuOption": "",
    "VisualAxisSortOption": "",
    "ExportWithHiddenFieldsOption": "",
    "DataPointDrillUpDownOption": "",
    "DataPointMenuLabelOption": "",
    "DataPointTooltipOption": ""
  ],
  "ThemeArn": "",
  "Definition": [
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": ["DefaultNewSheetConfiguration": ""]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

POST CreateDataSet

{{baseUrl}}/accounts/:AwsAccountId/data-sets

QUERY PARAMS

AwsAccountId

BODY json

{
  "DataSetId": "",
  "Name": "",
  "PhysicalTableMap": {},
  "LogicalTableMap": {},
  "ImportMode": "",
  "ColumnGroups": [
    {
      "GeoSpatialColumnGroup": ""
    }
  ],
  "FieldFolders": {},
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RowLevelPermissionDataSet": {
    "Namespace": "",
    "Arn": "",
    "PermissionPolicy": "",
    "FormatVersion": "",
    "Status": ""
  },
  "RowLevelPermissionTagConfiguration": {
    "Status": "",
    "TagRules": "",
    "TagRuleConfigurations": ""
  },
  "ColumnLevelPermissionRules": [
    {
      "Principals": "",
      "ColumnNames": ""
    }
  ],
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "DataSetUsageConfiguration": {
    "DisableUseAsDirectQuerySource": "",
    "DisableUseAsImportedSource": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/data-sets");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"DataSetId\": \"\",\n  \"Name\": \"\",\n  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/accounts/:AwsAccountId/data-sets" {:content-type :json
                                                                             :form-params {:DataSetId ""
                                                                                           :Name ""
                                                                                           :PhysicalTableMap {}
                                                                                           :LogicalTableMap {}
                                                                                           :ImportMode ""
                                                                                           :ColumnGroups [{:GeoSpatialColumnGroup ""}]
                                                                                           :FieldFolders {}
                                                                                           :Permissions [{:Principal ""
                                                                                                          :Actions ""}]
                                                                                           :RowLevelPermissionDataSet {:Namespace ""
                                                                                                                       :Arn ""
                                                                                                                       :PermissionPolicy ""
                                                                                                                       :FormatVersion ""
                                                                                                                       :Status ""}
                                                                                           :RowLevelPermissionTagConfiguration {:Status ""
                                                                                                                                :TagRules ""
                                                                                                                                :TagRuleConfigurations ""}
                                                                                           :ColumnLevelPermissionRules [{:Principals ""
                                                                                                                         :ColumnNames ""}]
                                                                                           :Tags [{:Key ""
                                                                                                   :Value ""}]
                                                                                           :DataSetUsageConfiguration {:DisableUseAsDirectQuerySource ""
                                                                                                                       :DisableUseAsImportedSource ""}}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"DataSetId\": \"\",\n  \"Name\": \"\",\n  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\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}}/accounts/:AwsAccountId/data-sets"),
    Content = new StringContent("{\n  \"DataSetId\": \"\",\n  \"Name\": \"\",\n  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\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}}/accounts/:AwsAccountId/data-sets");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DataSetId\": \"\",\n  \"Name\": \"\",\n  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/data-sets"

	payload := strings.NewReader("{\n  \"DataSetId\": \"\",\n  \"Name\": \"\",\n  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\n  }\n}")

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

	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/accounts/:AwsAccountId/data-sets HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 818

{
  "DataSetId": "",
  "Name": "",
  "PhysicalTableMap": {},
  "LogicalTableMap": {},
  "ImportMode": "",
  "ColumnGroups": [
    {
      "GeoSpatialColumnGroup": ""
    }
  ],
  "FieldFolders": {},
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RowLevelPermissionDataSet": {
    "Namespace": "",
    "Arn": "",
    "PermissionPolicy": "",
    "FormatVersion": "",
    "Status": ""
  },
  "RowLevelPermissionTagConfiguration": {
    "Status": "",
    "TagRules": "",
    "TagRuleConfigurations": ""
  },
  "ColumnLevelPermissionRules": [
    {
      "Principals": "",
      "ColumnNames": ""
    }
  ],
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "DataSetUsageConfiguration": {
    "DisableUseAsDirectQuerySource": "",
    "DisableUseAsImportedSource": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:AwsAccountId/data-sets")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DataSetId\": \"\",\n  \"Name\": \"\",\n  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/data-sets"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"DataSetId\": \"\",\n  \"Name\": \"\",\n  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\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  \"DataSetId\": \"\",\n  \"Name\": \"\",\n  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:AwsAccountId/data-sets")
  .header("content-type", "application/json")
  .body("{\n  \"DataSetId\": \"\",\n  \"Name\": \"\",\n  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  DataSetId: '',
  Name: '',
  PhysicalTableMap: {},
  LogicalTableMap: {},
  ImportMode: '',
  ColumnGroups: [
    {
      GeoSpatialColumnGroup: ''
    }
  ],
  FieldFolders: {},
  Permissions: [
    {
      Principal: '',
      Actions: ''
    }
  ],
  RowLevelPermissionDataSet: {
    Namespace: '',
    Arn: '',
    PermissionPolicy: '',
    FormatVersion: '',
    Status: ''
  },
  RowLevelPermissionTagConfiguration: {
    Status: '',
    TagRules: '',
    TagRuleConfigurations: ''
  },
  ColumnLevelPermissionRules: [
    {
      Principals: '',
      ColumnNames: ''
    }
  ],
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  DataSetUsageConfiguration: {
    DisableUseAsDirectQuerySource: '',
    DisableUseAsImportedSource: ''
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/accounts/:AwsAccountId/data-sets');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets',
  headers: {'content-type': 'application/json'},
  data: {
    DataSetId: '',
    Name: '',
    PhysicalTableMap: {},
    LogicalTableMap: {},
    ImportMode: '',
    ColumnGroups: [{GeoSpatialColumnGroup: ''}],
    FieldFolders: {},
    Permissions: [{Principal: '', Actions: ''}],
    RowLevelPermissionDataSet: {Namespace: '', Arn: '', PermissionPolicy: '', FormatVersion: '', Status: ''},
    RowLevelPermissionTagConfiguration: {Status: '', TagRules: '', TagRuleConfigurations: ''},
    ColumnLevelPermissionRules: [{Principals: '', ColumnNames: ''}],
    Tags: [{Key: '', Value: ''}],
    DataSetUsageConfiguration: {DisableUseAsDirectQuerySource: '', DisableUseAsImportedSource: ''}
  }
};

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DataSetId":"","Name":"","PhysicalTableMap":{},"LogicalTableMap":{},"ImportMode":"","ColumnGroups":[{"GeoSpatialColumnGroup":""}],"FieldFolders":{},"Permissions":[{"Principal":"","Actions":""}],"RowLevelPermissionDataSet":{"Namespace":"","Arn":"","PermissionPolicy":"","FormatVersion":"","Status":""},"RowLevelPermissionTagConfiguration":{"Status":"","TagRules":"","TagRuleConfigurations":""},"ColumnLevelPermissionRules":[{"Principals":"","ColumnNames":""}],"Tags":[{"Key":"","Value":""}],"DataSetUsageConfiguration":{"DisableUseAsDirectQuerySource":"","DisableUseAsImportedSource":""}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DataSetId": "",\n  "Name": "",\n  "PhysicalTableMap": {},\n  "LogicalTableMap": {},\n  "ImportMode": "",\n  "ColumnGroups": [\n    {\n      "GeoSpatialColumnGroup": ""\n    }\n  ],\n  "FieldFolders": {},\n  "Permissions": [\n    {\n      "Principal": "",\n      "Actions": ""\n    }\n  ],\n  "RowLevelPermissionDataSet": {\n    "Namespace": "",\n    "Arn": "",\n    "PermissionPolicy": "",\n    "FormatVersion": "",\n    "Status": ""\n  },\n  "RowLevelPermissionTagConfiguration": {\n    "Status": "",\n    "TagRules": "",\n    "TagRuleConfigurations": ""\n  },\n  "ColumnLevelPermissionRules": [\n    {\n      "Principals": "",\n      "ColumnNames": ""\n    }\n  ],\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "DataSetUsageConfiguration": {\n    "DisableUseAsDirectQuerySource": "",\n    "DisableUseAsImportedSource": ""\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  \"DataSetId\": \"\",\n  \"Name\": \"\",\n  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets")
  .post(body)
  .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/accounts/:AwsAccountId/data-sets',
  headers: {
    '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({
  DataSetId: '',
  Name: '',
  PhysicalTableMap: {},
  LogicalTableMap: {},
  ImportMode: '',
  ColumnGroups: [{GeoSpatialColumnGroup: ''}],
  FieldFolders: {},
  Permissions: [{Principal: '', Actions: ''}],
  RowLevelPermissionDataSet: {Namespace: '', Arn: '', PermissionPolicy: '', FormatVersion: '', Status: ''},
  RowLevelPermissionTagConfiguration: {Status: '', TagRules: '', TagRuleConfigurations: ''},
  ColumnLevelPermissionRules: [{Principals: '', ColumnNames: ''}],
  Tags: [{Key: '', Value: ''}],
  DataSetUsageConfiguration: {DisableUseAsDirectQuerySource: '', DisableUseAsImportedSource: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets',
  headers: {'content-type': 'application/json'},
  body: {
    DataSetId: '',
    Name: '',
    PhysicalTableMap: {},
    LogicalTableMap: {},
    ImportMode: '',
    ColumnGroups: [{GeoSpatialColumnGroup: ''}],
    FieldFolders: {},
    Permissions: [{Principal: '', Actions: ''}],
    RowLevelPermissionDataSet: {Namespace: '', Arn: '', PermissionPolicy: '', FormatVersion: '', Status: ''},
    RowLevelPermissionTagConfiguration: {Status: '', TagRules: '', TagRuleConfigurations: ''},
    ColumnLevelPermissionRules: [{Principals: '', ColumnNames: ''}],
    Tags: [{Key: '', Value: ''}],
    DataSetUsageConfiguration: {DisableUseAsDirectQuerySource: '', DisableUseAsImportedSource: ''}
  },
  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}}/accounts/:AwsAccountId/data-sets');

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

req.type('json');
req.send({
  DataSetId: '',
  Name: '',
  PhysicalTableMap: {},
  LogicalTableMap: {},
  ImportMode: '',
  ColumnGroups: [
    {
      GeoSpatialColumnGroup: ''
    }
  ],
  FieldFolders: {},
  Permissions: [
    {
      Principal: '',
      Actions: ''
    }
  ],
  RowLevelPermissionDataSet: {
    Namespace: '',
    Arn: '',
    PermissionPolicy: '',
    FormatVersion: '',
    Status: ''
  },
  RowLevelPermissionTagConfiguration: {
    Status: '',
    TagRules: '',
    TagRuleConfigurations: ''
  },
  ColumnLevelPermissionRules: [
    {
      Principals: '',
      ColumnNames: ''
    }
  ],
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  DataSetUsageConfiguration: {
    DisableUseAsDirectQuerySource: '',
    DisableUseAsImportedSource: ''
  }
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets',
  headers: {'content-type': 'application/json'},
  data: {
    DataSetId: '',
    Name: '',
    PhysicalTableMap: {},
    LogicalTableMap: {},
    ImportMode: '',
    ColumnGroups: [{GeoSpatialColumnGroup: ''}],
    FieldFolders: {},
    Permissions: [{Principal: '', Actions: ''}],
    RowLevelPermissionDataSet: {Namespace: '', Arn: '', PermissionPolicy: '', FormatVersion: '', Status: ''},
    RowLevelPermissionTagConfiguration: {Status: '', TagRules: '', TagRuleConfigurations: ''},
    ColumnLevelPermissionRules: [{Principals: '', ColumnNames: ''}],
    Tags: [{Key: '', Value: ''}],
    DataSetUsageConfiguration: {DisableUseAsDirectQuerySource: '', DisableUseAsImportedSource: ''}
  }
};

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

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DataSetId":"","Name":"","PhysicalTableMap":{},"LogicalTableMap":{},"ImportMode":"","ColumnGroups":[{"GeoSpatialColumnGroup":""}],"FieldFolders":{},"Permissions":[{"Principal":"","Actions":""}],"RowLevelPermissionDataSet":{"Namespace":"","Arn":"","PermissionPolicy":"","FormatVersion":"","Status":""},"RowLevelPermissionTagConfiguration":{"Status":"","TagRules":"","TagRuleConfigurations":""},"ColumnLevelPermissionRules":[{"Principals":"","ColumnNames":""}],"Tags":[{"Key":"","Value":""}],"DataSetUsageConfiguration":{"DisableUseAsDirectQuerySource":"","DisableUseAsImportedSource":""}}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"DataSetId": @"",
                              @"Name": @"",
                              @"PhysicalTableMap": @{  },
                              @"LogicalTableMap": @{  },
                              @"ImportMode": @"",
                              @"ColumnGroups": @[ @{ @"GeoSpatialColumnGroup": @"" } ],
                              @"FieldFolders": @{  },
                              @"Permissions": @[ @{ @"Principal": @"", @"Actions": @"" } ],
                              @"RowLevelPermissionDataSet": @{ @"Namespace": @"", @"Arn": @"", @"PermissionPolicy": @"", @"FormatVersion": @"", @"Status": @"" },
                              @"RowLevelPermissionTagConfiguration": @{ @"Status": @"", @"TagRules": @"", @"TagRuleConfigurations": @"" },
                              @"ColumnLevelPermissionRules": @[ @{ @"Principals": @"", @"ColumnNames": @"" } ],
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"DataSetUsageConfiguration": @{ @"DisableUseAsDirectQuerySource": @"", @"DisableUseAsImportedSource": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/data-sets"]
                                                       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}}/accounts/:AwsAccountId/data-sets" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"DataSetId\": \"\",\n  \"Name\": \"\",\n  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/accounts/:AwsAccountId/data-sets",
  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([
    'DataSetId' => '',
    'Name' => '',
    'PhysicalTableMap' => [
        
    ],
    'LogicalTableMap' => [
        
    ],
    'ImportMode' => '',
    'ColumnGroups' => [
        [
                'GeoSpatialColumnGroup' => ''
        ]
    ],
    'FieldFolders' => [
        
    ],
    'Permissions' => [
        [
                'Principal' => '',
                'Actions' => ''
        ]
    ],
    'RowLevelPermissionDataSet' => [
        'Namespace' => '',
        'Arn' => '',
        'PermissionPolicy' => '',
        'FormatVersion' => '',
        'Status' => ''
    ],
    'RowLevelPermissionTagConfiguration' => [
        'Status' => '',
        'TagRules' => '',
        'TagRuleConfigurations' => ''
    ],
    'ColumnLevelPermissionRules' => [
        [
                'Principals' => '',
                'ColumnNames' => ''
        ]
    ],
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'DataSetUsageConfiguration' => [
        'DisableUseAsDirectQuerySource' => '',
        'DisableUseAsImportedSource' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/accounts/:AwsAccountId/data-sets', [
  'body' => '{
  "DataSetId": "",
  "Name": "",
  "PhysicalTableMap": {},
  "LogicalTableMap": {},
  "ImportMode": "",
  "ColumnGroups": [
    {
      "GeoSpatialColumnGroup": ""
    }
  ],
  "FieldFolders": {},
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RowLevelPermissionDataSet": {
    "Namespace": "",
    "Arn": "",
    "PermissionPolicy": "",
    "FormatVersion": "",
    "Status": ""
  },
  "RowLevelPermissionTagConfiguration": {
    "Status": "",
    "TagRules": "",
    "TagRuleConfigurations": ""
  },
  "ColumnLevelPermissionRules": [
    {
      "Principals": "",
      "ColumnNames": ""
    }
  ],
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "DataSetUsageConfiguration": {
    "DisableUseAsDirectQuerySource": "",
    "DisableUseAsImportedSource": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DataSetId' => '',
  'Name' => '',
  'PhysicalTableMap' => [
    
  ],
  'LogicalTableMap' => [
    
  ],
  'ImportMode' => '',
  'ColumnGroups' => [
    [
        'GeoSpatialColumnGroup' => ''
    ]
  ],
  'FieldFolders' => [
    
  ],
  'Permissions' => [
    [
        'Principal' => '',
        'Actions' => ''
    ]
  ],
  'RowLevelPermissionDataSet' => [
    'Namespace' => '',
    'Arn' => '',
    'PermissionPolicy' => '',
    'FormatVersion' => '',
    'Status' => ''
  ],
  'RowLevelPermissionTagConfiguration' => [
    'Status' => '',
    'TagRules' => '',
    'TagRuleConfigurations' => ''
  ],
  'ColumnLevelPermissionRules' => [
    [
        'Principals' => '',
        'ColumnNames' => ''
    ]
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'DataSetUsageConfiguration' => [
    'DisableUseAsDirectQuerySource' => '',
    'DisableUseAsImportedSource' => ''
  ]
]));

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

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

append(json_encode([
  'DataSetId' => '',
  'Name' => '',
  'PhysicalTableMap' => [
    
  ],
  'LogicalTableMap' => [
    
  ],
  'ImportMode' => '',
  'ColumnGroups' => [
    [
        'GeoSpatialColumnGroup' => ''
    ]
  ],
  'FieldFolders' => [
    
  ],
  'Permissions' => [
    [
        'Principal' => '',
        'Actions' => ''
    ]
  ],
  'RowLevelPermissionDataSet' => [
    'Namespace' => '',
    'Arn' => '',
    'PermissionPolicy' => '',
    'FormatVersion' => '',
    'Status' => ''
  ],
  'RowLevelPermissionTagConfiguration' => [
    'Status' => '',
    'TagRules' => '',
    'TagRuleConfigurations' => ''
  ],
  'ColumnLevelPermissionRules' => [
    [
        'Principals' => '',
        'ColumnNames' => ''
    ]
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'DataSetUsageConfiguration' => [
    'DisableUseAsDirectQuerySource' => '',
    'DisableUseAsImportedSource' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DataSetId": "",
  "Name": "",
  "PhysicalTableMap": {},
  "LogicalTableMap": {},
  "ImportMode": "",
  "ColumnGroups": [
    {
      "GeoSpatialColumnGroup": ""
    }
  ],
  "FieldFolders": {},
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RowLevelPermissionDataSet": {
    "Namespace": "",
    "Arn": "",
    "PermissionPolicy": "",
    "FormatVersion": "",
    "Status": ""
  },
  "RowLevelPermissionTagConfiguration": {
    "Status": "",
    "TagRules": "",
    "TagRuleConfigurations": ""
  },
  "ColumnLevelPermissionRules": [
    {
      "Principals": "",
      "ColumnNames": ""
    }
  ],
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "DataSetUsageConfiguration": {
    "DisableUseAsDirectQuerySource": "",
    "DisableUseAsImportedSource": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DataSetId": "",
  "Name": "",
  "PhysicalTableMap": {},
  "LogicalTableMap": {},
  "ImportMode": "",
  "ColumnGroups": [
    {
      "GeoSpatialColumnGroup": ""
    }
  ],
  "FieldFolders": {},
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RowLevelPermissionDataSet": {
    "Namespace": "",
    "Arn": "",
    "PermissionPolicy": "",
    "FormatVersion": "",
    "Status": ""
  },
  "RowLevelPermissionTagConfiguration": {
    "Status": "",
    "TagRules": "",
    "TagRuleConfigurations": ""
  },
  "ColumnLevelPermissionRules": [
    {
      "Principals": "",
      "ColumnNames": ""
    }
  ],
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "DataSetUsageConfiguration": {
    "DisableUseAsDirectQuerySource": "",
    "DisableUseAsImportedSource": ""
  }
}'

import http.client

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

payload = "{\n  \"DataSetId\": \"\",\n  \"Name\": \"\",\n  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/accounts/:AwsAccountId/data-sets", payload, headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets"

payload = {
    "DataSetId": "",
    "Name": "",
    "PhysicalTableMap": {},
    "LogicalTableMap": {},
    "ImportMode": "",
    "ColumnGroups": [{ "GeoSpatialColumnGroup": "" }],
    "FieldFolders": {},
    "Permissions": [
        {
            "Principal": "",
            "Actions": ""
        }
    ],
    "RowLevelPermissionDataSet": {
        "Namespace": "",
        "Arn": "",
        "PermissionPolicy": "",
        "FormatVersion": "",
        "Status": ""
    },
    "RowLevelPermissionTagConfiguration": {
        "Status": "",
        "TagRules": "",
        "TagRuleConfigurations": ""
    },
    "ColumnLevelPermissionRules": [
        {
            "Principals": "",
            "ColumnNames": ""
        }
    ],
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "DataSetUsageConfiguration": {
        "DisableUseAsDirectQuerySource": "",
        "DisableUseAsImportedSource": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/data-sets"

payload <- "{\n  \"DataSetId\": \"\",\n  \"Name\": \"\",\n  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/data-sets")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"DataSetId\": \"\",\n  \"Name\": \"\",\n  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\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/accounts/:AwsAccountId/data-sets') do |req|
  req.body = "{\n  \"DataSetId\": \"\",\n  \"Name\": \"\",\n  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets";

    let payload = json!({
        "DataSetId": "",
        "Name": "",
        "PhysicalTableMap": json!({}),
        "LogicalTableMap": json!({}),
        "ImportMode": "",
        "ColumnGroups": (json!({"GeoSpatialColumnGroup": ""})),
        "FieldFolders": json!({}),
        "Permissions": (
            json!({
                "Principal": "",
                "Actions": ""
            })
        ),
        "RowLevelPermissionDataSet": json!({
            "Namespace": "",
            "Arn": "",
            "PermissionPolicy": "",
            "FormatVersion": "",
            "Status": ""
        }),
        "RowLevelPermissionTagConfiguration": json!({
            "Status": "",
            "TagRules": "",
            "TagRuleConfigurations": ""
        }),
        "ColumnLevelPermissionRules": (
            json!({
                "Principals": "",
                "ColumnNames": ""
            })
        ),
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "DataSetUsageConfiguration": json!({
            "DisableUseAsDirectQuerySource": "",
            "DisableUseAsImportedSource": ""
        })
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/accounts/:AwsAccountId/data-sets \
  --header 'content-type: application/json' \
  --data '{
  "DataSetId": "",
  "Name": "",
  "PhysicalTableMap": {},
  "LogicalTableMap": {},
  "ImportMode": "",
  "ColumnGroups": [
    {
      "GeoSpatialColumnGroup": ""
    }
  ],
  "FieldFolders": {},
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RowLevelPermissionDataSet": {
    "Namespace": "",
    "Arn": "",
    "PermissionPolicy": "",
    "FormatVersion": "",
    "Status": ""
  },
  "RowLevelPermissionTagConfiguration": {
    "Status": "",
    "TagRules": "",
    "TagRuleConfigurations": ""
  },
  "ColumnLevelPermissionRules": [
    {
      "Principals": "",
      "ColumnNames": ""
    }
  ],
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "DataSetUsageConfiguration": {
    "DisableUseAsDirectQuerySource": "",
    "DisableUseAsImportedSource": ""
  }
}'

echo '{
  "DataSetId": "",
  "Name": "",
  "PhysicalTableMap": {},
  "LogicalTableMap": {},
  "ImportMode": "",
  "ColumnGroups": [
    {
      "GeoSpatialColumnGroup": ""
    }
  ],
  "FieldFolders": {},
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RowLevelPermissionDataSet": {
    "Namespace": "",
    "Arn": "",
    "PermissionPolicy": "",
    "FormatVersion": "",
    "Status": ""
  },
  "RowLevelPermissionTagConfiguration": {
    "Status": "",
    "TagRules": "",
    "TagRuleConfigurations": ""
  },
  "ColumnLevelPermissionRules": [
    {
      "Principals": "",
      "ColumnNames": ""
    }
  ],
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "DataSetUsageConfiguration": {
    "DisableUseAsDirectQuerySource": "",
    "DisableUseAsImportedSource": ""
  }
}' |  \
  http POST {{baseUrl}}/accounts/:AwsAccountId/data-sets \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "DataSetId": "",\n  "Name": "",\n  "PhysicalTableMap": {},\n  "LogicalTableMap": {},\n  "ImportMode": "",\n  "ColumnGroups": [\n    {\n      "GeoSpatialColumnGroup": ""\n    }\n  ],\n  "FieldFolders": {},\n  "Permissions": [\n    {\n      "Principal": "",\n      "Actions": ""\n    }\n  ],\n  "RowLevelPermissionDataSet": {\n    "Namespace": "",\n    "Arn": "",\n    "PermissionPolicy": "",\n    "FormatVersion": "",\n    "Status": ""\n  },\n  "RowLevelPermissionTagConfiguration": {\n    "Status": "",\n    "TagRules": "",\n    "TagRuleConfigurations": ""\n  },\n  "ColumnLevelPermissionRules": [\n    {\n      "Principals": "",\n      "ColumnNames": ""\n    }\n  ],\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "DataSetUsageConfiguration": {\n    "DisableUseAsDirectQuerySource": "",\n    "DisableUseAsImportedSource": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/data-sets

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "DataSetId": "",
  "Name": "",
  "PhysicalTableMap": [],
  "LogicalTableMap": [],
  "ImportMode": "",
  "ColumnGroups": [["GeoSpatialColumnGroup": ""]],
  "FieldFolders": [],
  "Permissions": [
    [
      "Principal": "",
      "Actions": ""
    ]
  ],
  "RowLevelPermissionDataSet": [
    "Namespace": "",
    "Arn": "",
    "PermissionPolicy": "",
    "FormatVersion": "",
    "Status": ""
  ],
  "RowLevelPermissionTagConfiguration": [
    "Status": "",
    "TagRules": "",
    "TagRuleConfigurations": ""
  ],
  "ColumnLevelPermissionRules": [
    [
      "Principals": "",
      "ColumnNames": ""
    ]
  ],
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "DataSetUsageConfiguration": [
    "DisableUseAsDirectQuerySource": "",
    "DisableUseAsImportedSource": ""
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/data-sets")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

POST CreateDataSource

{{baseUrl}}/accounts/:AwsAccountId/data-sources

QUERY PARAMS

AwsAccountId

BODY json

{
  "DataSourceId": "",
  "Name": "",
  "Type": "",
  "DataSourceParameters": {
    "AmazonElasticsearchParameters": "",
    "AthenaParameters": "",
    "AuroraParameters": "",
    "AuroraPostgreSqlParameters": "",
    "AwsIotAnalyticsParameters": "",
    "JiraParameters": "",
    "MariaDbParameters": "",
    "MySqlParameters": "",
    "OracleParameters": "",
    "PostgreSqlParameters": "",
    "PrestoParameters": "",
    "RdsParameters": "",
    "RedshiftParameters": "",
    "S3Parameters": "",
    "ServiceNowParameters": "",
    "SnowflakeParameters": "",
    "SparkParameters": "",
    "SqlServerParameters": "",
    "TeradataParameters": "",
    "TwitterParameters": "",
    "AmazonOpenSearchParameters": "",
    "ExasolParameters": "",
    "DatabricksParameters": ""
  },
  "Credentials": {
    "CredentialPair": "",
    "CopySourceArn": "",
    "SecretArn": ""
  },
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "VpcConnectionProperties": {
    "VpcConnectionArn": ""
  },
  "SslProperties": {
    "DisableSsl": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/data-sources");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"DataSourceId\": \"\",\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/accounts/:AwsAccountId/data-sources" {:content-type :json
                                                                                :form-params {:DataSourceId ""
                                                                                              :Name ""
                                                                                              :Type ""
                                                                                              :DataSourceParameters {:AmazonElasticsearchParameters ""
                                                                                                                     :AthenaParameters ""
                                                                                                                     :AuroraParameters ""
                                                                                                                     :AuroraPostgreSqlParameters ""
                                                                                                                     :AwsIotAnalyticsParameters ""
                                                                                                                     :JiraParameters ""
                                                                                                                     :MariaDbParameters ""
                                                                                                                     :MySqlParameters ""
                                                                                                                     :OracleParameters ""
                                                                                                                     :PostgreSqlParameters ""
                                                                                                                     :PrestoParameters ""
                                                                                                                     :RdsParameters ""
                                                                                                                     :RedshiftParameters ""
                                                                                                                     :S3Parameters ""
                                                                                                                     :ServiceNowParameters ""
                                                                                                                     :SnowflakeParameters ""
                                                                                                                     :SparkParameters ""
                                                                                                                     :SqlServerParameters ""
                                                                                                                     :TeradataParameters ""
                                                                                                                     :TwitterParameters ""
                                                                                                                     :AmazonOpenSearchParameters ""
                                                                                                                     :ExasolParameters ""
                                                                                                                     :DatabricksParameters ""}
                                                                                              :Credentials {:CredentialPair ""
                                                                                                            :CopySourceArn ""
                                                                                                            :SecretArn ""}
                                                                                              :Permissions [{:Principal ""
                                                                                                             :Actions ""}]
                                                                                              :VpcConnectionProperties {:VpcConnectionArn ""}
                                                                                              :SslProperties {:DisableSsl ""}
                                                                                              :Tags [{:Key ""
                                                                                                      :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sources"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"DataSourceId\": \"\",\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/accounts/:AwsAccountId/data-sources"),
    Content = new StringContent("{\n  \"DataSourceId\": \"\",\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/accounts/:AwsAccountId/data-sources");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DataSourceId\": \"\",\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/data-sources"

	payload := strings.NewReader("{\n  \"DataSourceId\": \"\",\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

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

	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/accounts/:AwsAccountId/data-sources HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1131

{
  "DataSourceId": "",
  "Name": "",
  "Type": "",
  "DataSourceParameters": {
    "AmazonElasticsearchParameters": "",
    "AthenaParameters": "",
    "AuroraParameters": "",
    "AuroraPostgreSqlParameters": "",
    "AwsIotAnalyticsParameters": "",
    "JiraParameters": "",
    "MariaDbParameters": "",
    "MySqlParameters": "",
    "OracleParameters": "",
    "PostgreSqlParameters": "",
    "PrestoParameters": "",
    "RdsParameters": "",
    "RedshiftParameters": "",
    "S3Parameters": "",
    "ServiceNowParameters": "",
    "SnowflakeParameters": "",
    "SparkParameters": "",
    "SqlServerParameters": "",
    "TeradataParameters": "",
    "TwitterParameters": "",
    "AmazonOpenSearchParameters": "",
    "ExasolParameters": "",
    "DatabricksParameters": ""
  },
  "Credentials": {
    "CredentialPair": "",
    "CopySourceArn": "",
    "SecretArn": ""
  },
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "VpcConnectionProperties": {
    "VpcConnectionArn": ""
  },
  "SslProperties": {
    "DisableSsl": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:AwsAccountId/data-sources")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DataSourceId\": \"\",\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/data-sources"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"DataSourceId\": \"\",\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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  \"DataSourceId\": \"\",\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sources")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:AwsAccountId/data-sources")
  .header("content-type", "application/json")
  .body("{\n  \"DataSourceId\": \"\",\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  DataSourceId: '',
  Name: '',
  Type: '',
  DataSourceParameters: {
    AmazonElasticsearchParameters: '',
    AthenaParameters: '',
    AuroraParameters: '',
    AuroraPostgreSqlParameters: '',
    AwsIotAnalyticsParameters: '',
    JiraParameters: '',
    MariaDbParameters: '',
    MySqlParameters: '',
    OracleParameters: '',
    PostgreSqlParameters: '',
    PrestoParameters: '',
    RdsParameters: '',
    RedshiftParameters: '',
    S3Parameters: '',
    ServiceNowParameters: '',
    SnowflakeParameters: '',
    SparkParameters: '',
    SqlServerParameters: '',
    TeradataParameters: '',
    TwitterParameters: '',
    AmazonOpenSearchParameters: '',
    ExasolParameters: '',
    DatabricksParameters: ''
  },
  Credentials: {
    CredentialPair: '',
    CopySourceArn: '',
    SecretArn: ''
  },
  Permissions: [
    {
      Principal: '',
      Actions: ''
    }
  ],
  VpcConnectionProperties: {
    VpcConnectionArn: ''
  },
  SslProperties: {
    DisableSsl: ''
  },
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/accounts/:AwsAccountId/data-sources');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sources',
  headers: {'content-type': 'application/json'},
  data: {
    DataSourceId: '',
    Name: '',
    Type: '',
    DataSourceParameters: {
      AmazonElasticsearchParameters: '',
      AthenaParameters: '',
      AuroraParameters: '',
      AuroraPostgreSqlParameters: '',
      AwsIotAnalyticsParameters: '',
      JiraParameters: '',
      MariaDbParameters: '',
      MySqlParameters: '',
      OracleParameters: '',
      PostgreSqlParameters: '',
      PrestoParameters: '',
      RdsParameters: '',
      RedshiftParameters: '',
      S3Parameters: '',
      ServiceNowParameters: '',
      SnowflakeParameters: '',
      SparkParameters: '',
      SqlServerParameters: '',
      TeradataParameters: '',
      TwitterParameters: '',
      AmazonOpenSearchParameters: '',
      ExasolParameters: '',
      DatabricksParameters: ''
    },
    Credentials: {CredentialPair: '', CopySourceArn: '', SecretArn: ''},
    Permissions: [{Principal: '', Actions: ''}],
    VpcConnectionProperties: {VpcConnectionArn: ''},
    SslProperties: {DisableSsl: ''},
    Tags: [{Key: '', Value: ''}]
  }
};

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sources';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DataSourceId":"","Name":"","Type":"","DataSourceParameters":{"AmazonElasticsearchParameters":"","AthenaParameters":"","AuroraParameters":"","AuroraPostgreSqlParameters":"","AwsIotAnalyticsParameters":"","JiraParameters":"","MariaDbParameters":"","MySqlParameters":"","OracleParameters":"","PostgreSqlParameters":"","PrestoParameters":"","RdsParameters":"","RedshiftParameters":"","S3Parameters":"","ServiceNowParameters":"","SnowflakeParameters":"","SparkParameters":"","SqlServerParameters":"","TeradataParameters":"","TwitterParameters":"","AmazonOpenSearchParameters":"","ExasolParameters":"","DatabricksParameters":""},"Credentials":{"CredentialPair":"","CopySourceArn":"","SecretArn":""},"Permissions":[{"Principal":"","Actions":""}],"VpcConnectionProperties":{"VpcConnectionArn":""},"SslProperties":{"DisableSsl":""},"Tags":[{"Key":"","Value":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sources',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DataSourceId": "",\n  "Name": "",\n  "Type": "",\n  "DataSourceParameters": {\n    "AmazonElasticsearchParameters": "",\n    "AthenaParameters": "",\n    "AuroraParameters": "",\n    "AuroraPostgreSqlParameters": "",\n    "AwsIotAnalyticsParameters": "",\n    "JiraParameters": "",\n    "MariaDbParameters": "",\n    "MySqlParameters": "",\n    "OracleParameters": "",\n    "PostgreSqlParameters": "",\n    "PrestoParameters": "",\n    "RdsParameters": "",\n    "RedshiftParameters": "",\n    "S3Parameters": "",\n    "ServiceNowParameters": "",\n    "SnowflakeParameters": "",\n    "SparkParameters": "",\n    "SqlServerParameters": "",\n    "TeradataParameters": "",\n    "TwitterParameters": "",\n    "AmazonOpenSearchParameters": "",\n    "ExasolParameters": "",\n    "DatabricksParameters": ""\n  },\n  "Credentials": {\n    "CredentialPair": "",\n    "CopySourceArn": "",\n    "SecretArn": ""\n  },\n  "Permissions": [\n    {\n      "Principal": "",\n      "Actions": ""\n    }\n  ],\n  "VpcConnectionProperties": {\n    "VpcConnectionArn": ""\n  },\n  "SslProperties": {\n    "DisableSsl": ""\n  },\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\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  \"DataSourceId\": \"\",\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sources")
  .post(body)
  .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/accounts/:AwsAccountId/data-sources',
  headers: {
    '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({
  DataSourceId: '',
  Name: '',
  Type: '',
  DataSourceParameters: {
    AmazonElasticsearchParameters: '',
    AthenaParameters: '',
    AuroraParameters: '',
    AuroraPostgreSqlParameters: '',
    AwsIotAnalyticsParameters: '',
    JiraParameters: '',
    MariaDbParameters: '',
    MySqlParameters: '',
    OracleParameters: '',
    PostgreSqlParameters: '',
    PrestoParameters: '',
    RdsParameters: '',
    RedshiftParameters: '',
    S3Parameters: '',
    ServiceNowParameters: '',
    SnowflakeParameters: '',
    SparkParameters: '',
    SqlServerParameters: '',
    TeradataParameters: '',
    TwitterParameters: '',
    AmazonOpenSearchParameters: '',
    ExasolParameters: '',
    DatabricksParameters: ''
  },
  Credentials: {CredentialPair: '', CopySourceArn: '', SecretArn: ''},
  Permissions: [{Principal: '', Actions: ''}],
  VpcConnectionProperties: {VpcConnectionArn: ''},
  SslProperties: {DisableSsl: ''},
  Tags: [{Key: '', Value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sources',
  headers: {'content-type': 'application/json'},
  body: {
    DataSourceId: '',
    Name: '',
    Type: '',
    DataSourceParameters: {
      AmazonElasticsearchParameters: '',
      AthenaParameters: '',
      AuroraParameters: '',
      AuroraPostgreSqlParameters: '',
      AwsIotAnalyticsParameters: '',
      JiraParameters: '',
      MariaDbParameters: '',
      MySqlParameters: '',
      OracleParameters: '',
      PostgreSqlParameters: '',
      PrestoParameters: '',
      RdsParameters: '',
      RedshiftParameters: '',
      S3Parameters: '',
      ServiceNowParameters: '',
      SnowflakeParameters: '',
      SparkParameters: '',
      SqlServerParameters: '',
      TeradataParameters: '',
      TwitterParameters: '',
      AmazonOpenSearchParameters: '',
      ExasolParameters: '',
      DatabricksParameters: ''
    },
    Credentials: {CredentialPair: '', CopySourceArn: '', SecretArn: ''},
    Permissions: [{Principal: '', Actions: ''}],
    VpcConnectionProperties: {VpcConnectionArn: ''},
    SslProperties: {DisableSsl: ''},
    Tags: [{Key: '', Value: ''}]
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/accounts/:AwsAccountId/data-sources');

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

req.type('json');
req.send({
  DataSourceId: '',
  Name: '',
  Type: '',
  DataSourceParameters: {
    AmazonElasticsearchParameters: '',
    AthenaParameters: '',
    AuroraParameters: '',
    AuroraPostgreSqlParameters: '',
    AwsIotAnalyticsParameters: '',
    JiraParameters: '',
    MariaDbParameters: '',
    MySqlParameters: '',
    OracleParameters: '',
    PostgreSqlParameters: '',
    PrestoParameters: '',
    RdsParameters: '',
    RedshiftParameters: '',
    S3Parameters: '',
    ServiceNowParameters: '',
    SnowflakeParameters: '',
    SparkParameters: '',
    SqlServerParameters: '',
    TeradataParameters: '',
    TwitterParameters: '',
    AmazonOpenSearchParameters: '',
    ExasolParameters: '',
    DatabricksParameters: ''
  },
  Credentials: {
    CredentialPair: '',
    CopySourceArn: '',
    SecretArn: ''
  },
  Permissions: [
    {
      Principal: '',
      Actions: ''
    }
  ],
  VpcConnectionProperties: {
    VpcConnectionArn: ''
  },
  SslProperties: {
    DisableSsl: ''
  },
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sources',
  headers: {'content-type': 'application/json'},
  data: {
    DataSourceId: '',
    Name: '',
    Type: '',
    DataSourceParameters: {
      AmazonElasticsearchParameters: '',
      AthenaParameters: '',
      AuroraParameters: '',
      AuroraPostgreSqlParameters: '',
      AwsIotAnalyticsParameters: '',
      JiraParameters: '',
      MariaDbParameters: '',
      MySqlParameters: '',
      OracleParameters: '',
      PostgreSqlParameters: '',
      PrestoParameters: '',
      RdsParameters: '',
      RedshiftParameters: '',
      S3Parameters: '',
      ServiceNowParameters: '',
      SnowflakeParameters: '',
      SparkParameters: '',
      SqlServerParameters: '',
      TeradataParameters: '',
      TwitterParameters: '',
      AmazonOpenSearchParameters: '',
      ExasolParameters: '',
      DatabricksParameters: ''
    },
    Credentials: {CredentialPair: '', CopySourceArn: '', SecretArn: ''},
    Permissions: [{Principal: '', Actions: ''}],
    VpcConnectionProperties: {VpcConnectionArn: ''},
    SslProperties: {DisableSsl: ''},
    Tags: [{Key: '', Value: ''}]
  }
};

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

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sources';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DataSourceId":"","Name":"","Type":"","DataSourceParameters":{"AmazonElasticsearchParameters":"","AthenaParameters":"","AuroraParameters":"","AuroraPostgreSqlParameters":"","AwsIotAnalyticsParameters":"","JiraParameters":"","MariaDbParameters":"","MySqlParameters":"","OracleParameters":"","PostgreSqlParameters":"","PrestoParameters":"","RdsParameters":"","RedshiftParameters":"","S3Parameters":"","ServiceNowParameters":"","SnowflakeParameters":"","SparkParameters":"","SqlServerParameters":"","TeradataParameters":"","TwitterParameters":"","AmazonOpenSearchParameters":"","ExasolParameters":"","DatabricksParameters":""},"Credentials":{"CredentialPair":"","CopySourceArn":"","SecretArn":""},"Permissions":[{"Principal":"","Actions":""}],"VpcConnectionProperties":{"VpcConnectionArn":""},"SslProperties":{"DisableSsl":""},"Tags":[{"Key":"","Value":""}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"DataSourceId": @"",
                              @"Name": @"",
                              @"Type": @"",
                              @"DataSourceParameters": @{ @"AmazonElasticsearchParameters": @"", @"AthenaParameters": @"", @"AuroraParameters": @"", @"AuroraPostgreSqlParameters": @"", @"AwsIotAnalyticsParameters": @"", @"JiraParameters": @"", @"MariaDbParameters": @"", @"MySqlParameters": @"", @"OracleParameters": @"", @"PostgreSqlParameters": @"", @"PrestoParameters": @"", @"RdsParameters": @"", @"RedshiftParameters": @"", @"S3Parameters": @"", @"ServiceNowParameters": @"", @"SnowflakeParameters": @"", @"SparkParameters": @"", @"SqlServerParameters": @"", @"TeradataParameters": @"", @"TwitterParameters": @"", @"AmazonOpenSearchParameters": @"", @"ExasolParameters": @"", @"DatabricksParameters": @"" },
                              @"Credentials": @{ @"CredentialPair": @"", @"CopySourceArn": @"", @"SecretArn": @"" },
                              @"Permissions": @[ @{ @"Principal": @"", @"Actions": @"" } ],
                              @"VpcConnectionProperties": @{ @"VpcConnectionArn": @"" },
                              @"SslProperties": @{ @"DisableSsl": @"" },
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/data-sources"]
                                                       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}}/accounts/:AwsAccountId/data-sources" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"DataSourceId\": \"\",\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/accounts/:AwsAccountId/data-sources",
  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([
    'DataSourceId' => '',
    'Name' => '',
    'Type' => '',
    'DataSourceParameters' => [
        'AmazonElasticsearchParameters' => '',
        'AthenaParameters' => '',
        'AuroraParameters' => '',
        'AuroraPostgreSqlParameters' => '',
        'AwsIotAnalyticsParameters' => '',
        'JiraParameters' => '',
        'MariaDbParameters' => '',
        'MySqlParameters' => '',
        'OracleParameters' => '',
        'PostgreSqlParameters' => '',
        'PrestoParameters' => '',
        'RdsParameters' => '',
        'RedshiftParameters' => '',
        'S3Parameters' => '',
        'ServiceNowParameters' => '',
        'SnowflakeParameters' => '',
        'SparkParameters' => '',
        'SqlServerParameters' => '',
        'TeradataParameters' => '',
        'TwitterParameters' => '',
        'AmazonOpenSearchParameters' => '',
        'ExasolParameters' => '',
        'DatabricksParameters' => ''
    ],
    'Credentials' => [
        'CredentialPair' => '',
        'CopySourceArn' => '',
        'SecretArn' => ''
    ],
    'Permissions' => [
        [
                'Principal' => '',
                'Actions' => ''
        ]
    ],
    'VpcConnectionProperties' => [
        'VpcConnectionArn' => ''
    ],
    'SslProperties' => [
        'DisableSsl' => ''
    ],
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/accounts/:AwsAccountId/data-sources', [
  'body' => '{
  "DataSourceId": "",
  "Name": "",
  "Type": "",
  "DataSourceParameters": {
    "AmazonElasticsearchParameters": "",
    "AthenaParameters": "",
    "AuroraParameters": "",
    "AuroraPostgreSqlParameters": "",
    "AwsIotAnalyticsParameters": "",
    "JiraParameters": "",
    "MariaDbParameters": "",
    "MySqlParameters": "",
    "OracleParameters": "",
    "PostgreSqlParameters": "",
    "PrestoParameters": "",
    "RdsParameters": "",
    "RedshiftParameters": "",
    "S3Parameters": "",
    "ServiceNowParameters": "",
    "SnowflakeParameters": "",
    "SparkParameters": "",
    "SqlServerParameters": "",
    "TeradataParameters": "",
    "TwitterParameters": "",
    "AmazonOpenSearchParameters": "",
    "ExasolParameters": "",
    "DatabricksParameters": ""
  },
  "Credentials": {
    "CredentialPair": "",
    "CopySourceArn": "",
    "SecretArn": ""
  },
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "VpcConnectionProperties": {
    "VpcConnectionArn": ""
  },
  "SslProperties": {
    "DisableSsl": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sources');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DataSourceId' => '',
  'Name' => '',
  'Type' => '',
  'DataSourceParameters' => [
    'AmazonElasticsearchParameters' => '',
    'AthenaParameters' => '',
    'AuroraParameters' => '',
    'AuroraPostgreSqlParameters' => '',
    'AwsIotAnalyticsParameters' => '',
    'JiraParameters' => '',
    'MariaDbParameters' => '',
    'MySqlParameters' => '',
    'OracleParameters' => '',
    'PostgreSqlParameters' => '',
    'PrestoParameters' => '',
    'RdsParameters' => '',
    'RedshiftParameters' => '',
    'S3Parameters' => '',
    'ServiceNowParameters' => '',
    'SnowflakeParameters' => '',
    'SparkParameters' => '',
    'SqlServerParameters' => '',
    'TeradataParameters' => '',
    'TwitterParameters' => '',
    'AmazonOpenSearchParameters' => '',
    'ExasolParameters' => '',
    'DatabricksParameters' => ''
  ],
  'Credentials' => [
    'CredentialPair' => '',
    'CopySourceArn' => '',
    'SecretArn' => ''
  ],
  'Permissions' => [
    [
        'Principal' => '',
        'Actions' => ''
    ]
  ],
  'VpcConnectionProperties' => [
    'VpcConnectionArn' => ''
  ],
  'SslProperties' => [
    'DisableSsl' => ''
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'DataSourceId' => '',
  'Name' => '',
  'Type' => '',
  'DataSourceParameters' => [
    'AmazonElasticsearchParameters' => '',
    'AthenaParameters' => '',
    'AuroraParameters' => '',
    'AuroraPostgreSqlParameters' => '',
    'AwsIotAnalyticsParameters' => '',
    'JiraParameters' => '',
    'MariaDbParameters' => '',
    'MySqlParameters' => '',
    'OracleParameters' => '',
    'PostgreSqlParameters' => '',
    'PrestoParameters' => '',
    'RdsParameters' => '',
    'RedshiftParameters' => '',
    'S3Parameters' => '',
    'ServiceNowParameters' => '',
    'SnowflakeParameters' => '',
    'SparkParameters' => '',
    'SqlServerParameters' => '',
    'TeradataParameters' => '',
    'TwitterParameters' => '',
    'AmazonOpenSearchParameters' => '',
    'ExasolParameters' => '',
    'DatabricksParameters' => ''
  ],
  'Credentials' => [
    'CredentialPair' => '',
    'CopySourceArn' => '',
    'SecretArn' => ''
  ],
  'Permissions' => [
    [
        'Principal' => '',
        'Actions' => ''
    ]
  ],
  'VpcConnectionProperties' => [
    'VpcConnectionArn' => ''
  ],
  'SslProperties' => [
    'DisableSsl' => ''
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sources');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sources' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DataSourceId": "",
  "Name": "",
  "Type": "",
  "DataSourceParameters": {
    "AmazonElasticsearchParameters": "",
    "AthenaParameters": "",
    "AuroraParameters": "",
    "AuroraPostgreSqlParameters": "",
    "AwsIotAnalyticsParameters": "",
    "JiraParameters": "",
    "MariaDbParameters": "",
    "MySqlParameters": "",
    "OracleParameters": "",
    "PostgreSqlParameters": "",
    "PrestoParameters": "",
    "RdsParameters": "",
    "RedshiftParameters": "",
    "S3Parameters": "",
    "ServiceNowParameters": "",
    "SnowflakeParameters": "",
    "SparkParameters": "",
    "SqlServerParameters": "",
    "TeradataParameters": "",
    "TwitterParameters": "",
    "AmazonOpenSearchParameters": "",
    "ExasolParameters": "",
    "DatabricksParameters": ""
  },
  "Credentials": {
    "CredentialPair": "",
    "CopySourceArn": "",
    "SecretArn": ""
  },
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "VpcConnectionProperties": {
    "VpcConnectionArn": ""
  },
  "SslProperties": {
    "DisableSsl": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sources' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DataSourceId": "",
  "Name": "",
  "Type": "",
  "DataSourceParameters": {
    "AmazonElasticsearchParameters": "",
    "AthenaParameters": "",
    "AuroraParameters": "",
    "AuroraPostgreSqlParameters": "",
    "AwsIotAnalyticsParameters": "",
    "JiraParameters": "",
    "MariaDbParameters": "",
    "MySqlParameters": "",
    "OracleParameters": "",
    "PostgreSqlParameters": "",
    "PrestoParameters": "",
    "RdsParameters": "",
    "RedshiftParameters": "",
    "S3Parameters": "",
    "ServiceNowParameters": "",
    "SnowflakeParameters": "",
    "SparkParameters": "",
    "SqlServerParameters": "",
    "TeradataParameters": "",
    "TwitterParameters": "",
    "AmazonOpenSearchParameters": "",
    "ExasolParameters": "",
    "DatabricksParameters": ""
  },
  "Credentials": {
    "CredentialPair": "",
    "CopySourceArn": "",
    "SecretArn": ""
  },
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "VpcConnectionProperties": {
    "VpcConnectionArn": ""
  },
  "SslProperties": {
    "DisableSsl": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"DataSourceId\": \"\",\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/accounts/:AwsAccountId/data-sources", payload, headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sources"

payload = {
    "DataSourceId": "",
    "Name": "",
    "Type": "",
    "DataSourceParameters": {
        "AmazonElasticsearchParameters": "",
        "AthenaParameters": "",
        "AuroraParameters": "",
        "AuroraPostgreSqlParameters": "",
        "AwsIotAnalyticsParameters": "",
        "JiraParameters": "",
        "MariaDbParameters": "",
        "MySqlParameters": "",
        "OracleParameters": "",
        "PostgreSqlParameters": "",
        "PrestoParameters": "",
        "RdsParameters": "",
        "RedshiftParameters": "",
        "S3Parameters": "",
        "ServiceNowParameters": "",
        "SnowflakeParameters": "",
        "SparkParameters": "",
        "SqlServerParameters": "",
        "TeradataParameters": "",
        "TwitterParameters": "",
        "AmazonOpenSearchParameters": "",
        "ExasolParameters": "",
        "DatabricksParameters": ""
    },
    "Credentials": {
        "CredentialPair": "",
        "CopySourceArn": "",
        "SecretArn": ""
    },
    "Permissions": [
        {
            "Principal": "",
            "Actions": ""
        }
    ],
    "VpcConnectionProperties": { "VpcConnectionArn": "" },
    "SslProperties": { "DisableSsl": "" },
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/data-sources"

payload <- "{\n  \"DataSourceId\": \"\",\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/data-sources")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"DataSourceId\": \"\",\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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/accounts/:AwsAccountId/data-sources') do |req|
  req.body = "{\n  \"DataSourceId\": \"\",\n  \"Name\": \"\",\n  \"Type\": \"\",\n  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/data-sources";

    let payload = json!({
        "DataSourceId": "",
        "Name": "",
        "Type": "",
        "DataSourceParameters": json!({
            "AmazonElasticsearchParameters": "",
            "AthenaParameters": "",
            "AuroraParameters": "",
            "AuroraPostgreSqlParameters": "",
            "AwsIotAnalyticsParameters": "",
            "JiraParameters": "",
            "MariaDbParameters": "",
            "MySqlParameters": "",
            "OracleParameters": "",
            "PostgreSqlParameters": "",
            "PrestoParameters": "",
            "RdsParameters": "",
            "RedshiftParameters": "",
            "S3Parameters": "",
            "ServiceNowParameters": "",
            "SnowflakeParameters": "",
            "SparkParameters": "",
            "SqlServerParameters": "",
            "TeradataParameters": "",
            "TwitterParameters": "",
            "AmazonOpenSearchParameters": "",
            "ExasolParameters": "",
            "DatabricksParameters": ""
        }),
        "Credentials": json!({
            "CredentialPair": "",
            "CopySourceArn": "",
            "SecretArn": ""
        }),
        "Permissions": (
            json!({
                "Principal": "",
                "Actions": ""
            })
        ),
        "VpcConnectionProperties": json!({"VpcConnectionArn": ""}),
        "SslProperties": json!({"DisableSsl": ""}),
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/accounts/:AwsAccountId/data-sources \
  --header 'content-type: application/json' \
  --data '{
  "DataSourceId": "",
  "Name": "",
  "Type": "",
  "DataSourceParameters": {
    "AmazonElasticsearchParameters": "",
    "AthenaParameters": "",
    "AuroraParameters": "",
    "AuroraPostgreSqlParameters": "",
    "AwsIotAnalyticsParameters": "",
    "JiraParameters": "",
    "MariaDbParameters": "",
    "MySqlParameters": "",
    "OracleParameters": "",
    "PostgreSqlParameters": "",
    "PrestoParameters": "",
    "RdsParameters": "",
    "RedshiftParameters": "",
    "S3Parameters": "",
    "ServiceNowParameters": "",
    "SnowflakeParameters": "",
    "SparkParameters": "",
    "SqlServerParameters": "",
    "TeradataParameters": "",
    "TwitterParameters": "",
    "AmazonOpenSearchParameters": "",
    "ExasolParameters": "",
    "DatabricksParameters": ""
  },
  "Credentials": {
    "CredentialPair": "",
    "CopySourceArn": "",
    "SecretArn": ""
  },
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "VpcConnectionProperties": {
    "VpcConnectionArn": ""
  },
  "SslProperties": {
    "DisableSsl": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

echo '{
  "DataSourceId": "",
  "Name": "",
  "Type": "",
  "DataSourceParameters": {
    "AmazonElasticsearchParameters": "",
    "AthenaParameters": "",
    "AuroraParameters": "",
    "AuroraPostgreSqlParameters": "",
    "AwsIotAnalyticsParameters": "",
    "JiraParameters": "",
    "MariaDbParameters": "",
    "MySqlParameters": "",
    "OracleParameters": "",
    "PostgreSqlParameters": "",
    "PrestoParameters": "",
    "RdsParameters": "",
    "RedshiftParameters": "",
    "S3Parameters": "",
    "ServiceNowParameters": "",
    "SnowflakeParameters": "",
    "SparkParameters": "",
    "SqlServerParameters": "",
    "TeradataParameters": "",
    "TwitterParameters": "",
    "AmazonOpenSearchParameters": "",
    "ExasolParameters": "",
    "DatabricksParameters": ""
  },
  "Credentials": {
    "CredentialPair": "",
    "CopySourceArn": "",
    "SecretArn": ""
  },
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "VpcConnectionProperties": {
    "VpcConnectionArn": ""
  },
  "SslProperties": {
    "DisableSsl": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/accounts/:AwsAccountId/data-sources \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "DataSourceId": "",\n  "Name": "",\n  "Type": "",\n  "DataSourceParameters": {\n    "AmazonElasticsearchParameters": "",\n    "AthenaParameters": "",\n    "AuroraParameters": "",\n    "AuroraPostgreSqlParameters": "",\n    "AwsIotAnalyticsParameters": "",\n    "JiraParameters": "",\n    "MariaDbParameters": "",\n    "MySqlParameters": "",\n    "OracleParameters": "",\n    "PostgreSqlParameters": "",\n    "PrestoParameters": "",\n    "RdsParameters": "",\n    "RedshiftParameters": "",\n    "S3Parameters": "",\n    "ServiceNowParameters": "",\n    "SnowflakeParameters": "",\n    "SparkParameters": "",\n    "SqlServerParameters": "",\n    "TeradataParameters": "",\n    "TwitterParameters": "",\n    "AmazonOpenSearchParameters": "",\n    "ExasolParameters": "",\n    "DatabricksParameters": ""\n  },\n  "Credentials": {\n    "CredentialPair": "",\n    "CopySourceArn": "",\n    "SecretArn": ""\n  },\n  "Permissions": [\n    {\n      "Principal": "",\n      "Actions": ""\n    }\n  ],\n  "VpcConnectionProperties": {\n    "VpcConnectionArn": ""\n  },\n  "SslProperties": {\n    "DisableSsl": ""\n  },\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/data-sources

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "DataSourceId": "",
  "Name": "",
  "Type": "",
  "DataSourceParameters": [
    "AmazonElasticsearchParameters": "",
    "AthenaParameters": "",
    "AuroraParameters": "",
    "AuroraPostgreSqlParameters": "",
    "AwsIotAnalyticsParameters": "",
    "JiraParameters": "",
    "MariaDbParameters": "",
    "MySqlParameters": "",
    "OracleParameters": "",
    "PostgreSqlParameters": "",
    "PrestoParameters": "",
    "RdsParameters": "",
    "RedshiftParameters": "",
    "S3Parameters": "",
    "ServiceNowParameters": "",
    "SnowflakeParameters": "",
    "SparkParameters": "",
    "SqlServerParameters": "",
    "TeradataParameters": "",
    "TwitterParameters": "",
    "AmazonOpenSearchParameters": "",
    "ExasolParameters": "",
    "DatabricksParameters": ""
  ],
  "Credentials": [
    "CredentialPair": "",
    "CopySourceArn": "",
    "SecretArn": ""
  ],
  "Permissions": [
    [
      "Principal": "",
      "Actions": ""
    ]
  ],
  "VpcConnectionProperties": ["VpcConnectionArn": ""],
  "SslProperties": ["DisableSsl": ""],
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/data-sources")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

POST CreateFolder

{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId

QUERY PARAMS

AwsAccountId

FolderId

BODY json

{
  "Name": "",
  "FolderType": "",
  "ParentFolderArn": "",
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId");

struct curl_slist *headers = NULL;
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  \"FolderType\": \"\",\n  \"ParentFolderArn\": \"\",\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId" {:content-type :json
                                                                                     :form-params {:Name ""
                                                                                                   :FolderType ""
                                                                                                   :ParentFolderArn ""
                                                                                                   :Permissions [{:Principal ""
                                                                                                                  :Actions ""}]
                                                                                                   :Tags [{:Key ""
                                                                                                           :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"FolderType\": \"\",\n  \"ParentFolderArn\": \"\",\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/accounts/:AwsAccountId/folders/:FolderId"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"FolderType\": \"\",\n  \"ParentFolderArn\": \"\",\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/accounts/:AwsAccountId/folders/:FolderId");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"FolderType\": \"\",\n  \"ParentFolderArn\": \"\",\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"FolderType\": \"\",\n  \"ParentFolderArn\": \"\",\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

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

	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/accounts/:AwsAccountId/folders/:FolderId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 204

{
  "Name": "",
  "FolderType": "",
  "ParentFolderArn": "",
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"FolderType\": \"\",\n  \"ParentFolderArn\": \"\",\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"FolderType\": \"\",\n  \"ParentFolderArn\": \"\",\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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  \"Name\": \"\",\n  \"FolderType\": \"\",\n  \"ParentFolderArn\": \"\",\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"FolderType\": \"\",\n  \"ParentFolderArn\": \"\",\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  FolderType: '',
  ParentFolderArn: '',
  Permissions: [
    {
      Principal: '',
      Actions: ''
    }
  ],
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    FolderType: '',
    ParentFolderArn: '',
    Permissions: [{Principal: '', Actions: ''}],
    Tags: [{Key: '', Value: ''}]
  }
};

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","FolderType":"","ParentFolderArn":"","Permissions":[{"Principal":"","Actions":""}],"Tags":[{"Key":"","Value":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "FolderType": "",\n  "ParentFolderArn": "",\n  "Permissions": [\n    {\n      "Principal": "",\n      "Actions": ""\n    }\n  ],\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\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  \"Name\": \"\",\n  \"FolderType\": \"\",\n  \"ParentFolderArn\": \"\",\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId")
  .post(body)
  .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/accounts/:AwsAccountId/folders/:FolderId',
  headers: {
    '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: '',
  FolderType: '',
  ParentFolderArn: '',
  Permissions: [{Principal: '', Actions: ''}],
  Tags: [{Key: '', Value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId',
  headers: {'content-type': 'application/json'},
  body: {
    Name: '',
    FolderType: '',
    ParentFolderArn: '',
    Permissions: [{Principal: '', Actions: ''}],
    Tags: [{Key: '', Value: ''}]
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId');

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

req.type('json');
req.send({
  Name: '',
  FolderType: '',
  ParentFolderArn: '',
  Permissions: [
    {
      Principal: '',
      Actions: ''
    }
  ],
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    FolderType: '',
    ParentFolderArn: '',
    Permissions: [{Principal: '', Actions: ''}],
    Tags: [{Key: '', Value: ''}]
  }
};

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

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","FolderType":"","ParentFolderArn":"","Permissions":[{"Principal":"","Actions":""}],"Tags":[{"Key":"","Value":""}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"FolderType": @"",
                              @"ParentFolderArn": @"",
                              @"Permissions": @[ @{ @"Principal": @"", @"Actions": @"" } ],
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId"]
                                                       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}}/accounts/:AwsAccountId/folders/:FolderId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"FolderType\": \"\",\n  \"ParentFolderArn\": \"\",\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId",
  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' => '',
    'FolderType' => '',
    'ParentFolderArn' => '',
    'Permissions' => [
        [
                'Principal' => '',
                'Actions' => ''
        ]
    ],
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId', [
  'body' => '{
  "Name": "",
  "FolderType": "",
  "ParentFolderArn": "",
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'FolderType' => '',
  'ParentFolderArn' => '',
  'Permissions' => [
    [
        'Principal' => '',
        'Actions' => ''
    ]
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'Name' => '',
  'FolderType' => '',
  'ParentFolderArn' => '',
  'Permissions' => [
    [
        'Principal' => '',
        'Actions' => ''
    ]
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "FolderType": "",
  "ParentFolderArn": "",
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "FolderType": "",
  "ParentFolderArn": "",
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"FolderType\": \"\",\n  \"ParentFolderArn\": \"\",\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/accounts/:AwsAccountId/folders/:FolderId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId"

payload = {
    "Name": "",
    "FolderType": "",
    "ParentFolderArn": "",
    "Permissions": [
        {
            "Principal": "",
            "Actions": ""
        }
    ],
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId"

payload <- "{\n  \"Name\": \"\",\n  \"FolderType\": \"\",\n  \"ParentFolderArn\": \"\",\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"FolderType\": \"\",\n  \"ParentFolderArn\": \"\",\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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/accounts/:AwsAccountId/folders/:FolderId') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"FolderType\": \"\",\n  \"ParentFolderArn\": \"\",\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId";

    let payload = json!({
        "Name": "",
        "FolderType": "",
        "ParentFolderArn": "",
        "Permissions": (
            json!({
                "Principal": "",
                "Actions": ""
            })
        ),
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId \
  --header 'content-type: application/json' \
  --data '{
  "Name": "",
  "FolderType": "",
  "ParentFolderArn": "",
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

echo '{
  "Name": "",
  "FolderType": "",
  "ParentFolderArn": "",
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "FolderType": "",\n  "ParentFolderArn": "",\n  "Permissions": [\n    {\n      "Principal": "",\n      "Actions": ""\n    }\n  ],\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "FolderType": "",
  "ParentFolderArn": "",
  "Permissions": [
    [
      "Principal": "",
      "Actions": ""
    ]
  ],
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId")! 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()

PUT CreateFolderMembership

{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId

QUERY PARAMS

AwsAccountId

FolderId

MemberId

MemberType

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId"

response = HTTP::Client.put url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId"

	req, _ := http.NewRequest("PUT", url, nil)

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

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

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

}

PUT /baseUrl/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId"))
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId")
  .put(null)
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId")
  .asString();

const data = null;

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

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

xhr.open('PUT', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId'
};

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId';
const options = {method: 'PUT'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId',
  method: 'PUT',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId")
  .put(null)
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId');

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId'
};

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

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId';
const options = {method: 'PUT'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId" in

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

 "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId');
$request->setMethod(HTTP_METH_PUT);

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

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

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId' -Method PUT

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId' -Method PUT

import http.client

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

conn.request("PUT", "/baseUrl/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId")

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

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

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId"

response <- VERB("PUT", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId")

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

request = Net::HTTP::Put.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId

http PUT {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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

dataTask.resume()

POST CreateGroup

{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups

QUERY PARAMS

AwsAccountId

Namespace

BODY json

{
  "GroupName": "",
  "Description": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups" {:content-type :json
                                                                                                :form-params {:GroupName ""
                                                                                                              :Description ""}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"GroupName\": \"\",\n  \"Description\": \"\"\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}}/accounts/:AwsAccountId/namespaces/:Namespace/groups"),
    Content = new StringContent("{\n  \"GroupName\": \"\",\n  \"Description\": \"\"\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}}/accounts/:AwsAccountId/namespaces/:Namespace/groups");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GroupName\": \"\",\n  \"Description\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups"

	payload := strings.NewReader("{\n  \"GroupName\": \"\",\n  \"Description\": \"\"\n}")

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

	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/accounts/:AwsAccountId/namespaces/:Namespace/groups HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 42

{
  "GroupName": "",
  "Description": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GroupName\": \"\",\n  \"Description\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GroupName\": \"\",\n  \"Description\": \"\"\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  \"GroupName\": \"\",\n  \"Description\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups")
  .header("content-type", "application/json")
  .body("{\n  \"GroupName\": \"\",\n  \"Description\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GroupName: '',
  Description: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups',
  headers: {'content-type': 'application/json'},
  data: {GroupName: '', Description: ''}
};

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"GroupName":"","Description":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GroupName": "",\n  "Description": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GroupName\": \"\",\n  \"Description\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups")
  .post(body)
  .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/accounts/:AwsAccountId/namespaces/:Namespace/groups',
  headers: {
    '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({GroupName: '', Description: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups',
  headers: {'content-type': 'application/json'},
  body: {GroupName: '', Description: ''},
  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}}/accounts/:AwsAccountId/namespaces/:Namespace/groups');

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

req.type('json');
req.send({
  GroupName: '',
  Description: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups',
  headers: {'content-type': 'application/json'},
  data: {GroupName: '', Description: ''}
};

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

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"GroupName":"","Description":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GroupName": @"",
                              @"Description": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups"]
                                                       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}}/accounts/:AwsAccountId/namespaces/:Namespace/groups" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"GroupName\": \"\",\n  \"Description\": \"\"\n}" in

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

 "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups",
  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([
    'GroupName' => '',
    'Description' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups', [
  'body' => '{
  "GroupName": "",
  "Description": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'GroupName' => '',
  'Description' => ''
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GroupName": "",
  "Description": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GroupName": "",
  "Description": ""
}'

import http.client

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

payload = "{\n  \"GroupName\": \"\",\n  \"Description\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups", payload, headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups"

payload = {
    "GroupName": "",
    "Description": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups"

payload <- "{\n  \"GroupName\": \"\",\n  \"Description\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"GroupName\": \"\",\n  \"Description\": \"\"\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/accounts/:AwsAccountId/namespaces/:Namespace/groups') do |req|
  req.body = "{\n  \"GroupName\": \"\",\n  \"Description\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups";

    let payload = json!({
        "GroupName": "",
        "Description": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups \
  --header 'content-type: application/json' \
  --data '{
  "GroupName": "",
  "Description": ""
}'

echo '{
  "GroupName": "",
  "Description": ""
}' |  \
  http POST {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "GroupName": "",\n  "Description": ""\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "GroupName": "",
  "Description": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups")! 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()

PUT CreateGroupMembership

{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName

QUERY PARAMS

MemberName

GroupName

AwsAccountId

Namespace

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName"

response = HTTP::Client.put url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName"

	req, _ := http.NewRequest("PUT", url, nil)

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

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

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

}

PUT /baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName"))
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName")
  .put(null)
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName")
  .asString();

const data = null;

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

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

xhr.open('PUT', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName'
};

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName';
const options = {method: 'PUT'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName',
  method: 'PUT',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName")
  .put(null)
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName');

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName'
};

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

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName';
const options = {method: 'PUT'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName" in

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

 "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName');
$request->setMethod(HTTP_METH_PUT);

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

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

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName' -Method PUT

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName' -Method PUT

import http.client

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

conn.request("PUT", "/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName")

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

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

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName"

response <- VERB("PUT", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName")

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

request = Net::HTTP::Put.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName

http PUT {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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

dataTask.resume()

POST CreateIAMPolicyAssignment

{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/

QUERY PARAMS

AwsAccountId

Namespace

BODY json

{
  "AssignmentName": "",
  "AssignmentStatus": "",
  "PolicyArn": "",
  "Identities": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"AssignmentName\": \"\",\n  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/" {:content-type :json
                                                                                                                 :form-params {:AssignmentName ""
                                                                                                                               :AssignmentStatus ""
                                                                                                                               :PolicyArn ""
                                                                                                                               :Identities {}}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"AssignmentName\": \"\",\n  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\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}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/"),
    Content = new StringContent("{\n  \"AssignmentName\": \"\",\n  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\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}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AssignmentName\": \"\",\n  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/"

	payload := strings.NewReader("{\n  \"AssignmentName\": \"\",\n  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\n}")

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

	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/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 91

{
  "AssignmentName": "",
  "AssignmentStatus": "",
  "PolicyArn": "",
  "Identities": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AssignmentName\": \"\",\n  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AssignmentName\": \"\",\n  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\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  \"AssignmentName\": \"\",\n  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/")
  .header("content-type", "application/json")
  .body("{\n  \"AssignmentName\": \"\",\n  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\n}")
  .asString();

const data = JSON.stringify({
  AssignmentName: '',
  AssignmentStatus: '',
  PolicyArn: '',
  Identities: {}
});

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

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

xhr.open('POST', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/',
  headers: {'content-type': 'application/json'},
  data: {AssignmentName: '', AssignmentStatus: '', PolicyArn: '', Identities: {}}
};

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"AssignmentName":"","AssignmentStatus":"","PolicyArn":"","Identities":{}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AssignmentName": "",\n  "AssignmentStatus": "",\n  "PolicyArn": "",\n  "Identities": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AssignmentName\": \"\",\n  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/")
  .post(body)
  .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/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/',
  headers: {
    '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({AssignmentName: '', AssignmentStatus: '', PolicyArn: '', Identities: {}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/',
  headers: {'content-type': 'application/json'},
  body: {AssignmentName: '', AssignmentStatus: '', PolicyArn: '', Identities: {}},
  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}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/');

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

req.type('json');
req.send({
  AssignmentName: '',
  AssignmentStatus: '',
  PolicyArn: '',
  Identities: {}
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/',
  headers: {'content-type': 'application/json'},
  data: {AssignmentName: '', AssignmentStatus: '', PolicyArn: '', Identities: {}}
};

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

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"AssignmentName":"","AssignmentStatus":"","PolicyArn":"","Identities":{}}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AssignmentName": @"",
                              @"AssignmentStatus": @"",
                              @"PolicyArn": @"",
                              @"Identities": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/"]
                                                       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}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"AssignmentName\": \"\",\n  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\n}" in

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

 "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/",
  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([
    'AssignmentName' => '',
    'AssignmentStatus' => '',
    'PolicyArn' => '',
    'Identities' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/', [
  'body' => '{
  "AssignmentName": "",
  "AssignmentStatus": "",
  "PolicyArn": "",
  "Identities": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AssignmentName' => '',
  'AssignmentStatus' => '',
  'PolicyArn' => '',
  'Identities' => [
    
  ]
]));

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

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

append(json_encode([
  'AssignmentName' => '',
  'AssignmentStatus' => '',
  'PolicyArn' => '',
  'Identities' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AssignmentName": "",
  "AssignmentStatus": "",
  "PolicyArn": "",
  "Identities": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AssignmentName": "",
  "AssignmentStatus": "",
  "PolicyArn": "",
  "Identities": {}
}'

import http.client

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

payload = "{\n  \"AssignmentName\": \"\",\n  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/", payload, headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/"

payload = {
    "AssignmentName": "",
    "AssignmentStatus": "",
    "PolicyArn": "",
    "Identities": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/"

payload <- "{\n  \"AssignmentName\": \"\",\n  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"AssignmentName\": \"\",\n  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\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/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/') do |req|
  req.body = "{\n  \"AssignmentName\": \"\",\n  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/";

    let payload = json!({
        "AssignmentName": "",
        "AssignmentStatus": "",
        "PolicyArn": "",
        "Identities": json!({})
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/ \
  --header 'content-type: application/json' \
  --data '{
  "AssignmentName": "",
  "AssignmentStatus": "",
  "PolicyArn": "",
  "Identities": {}
}'

echo '{
  "AssignmentName": "",
  "AssignmentStatus": "",
  "PolicyArn": "",
  "Identities": {}
}' |  \
  http POST {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/ \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "AssignmentName": "",\n  "AssignmentStatus": "",\n  "PolicyArn": "",\n  "Identities": {}\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "AssignmentName": "",
  "AssignmentStatus": "",
  "PolicyArn": "",
  "Identities": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/")! 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()

PUT CreateIngestion

{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId

QUERY PARAMS

DataSetId

IngestionId

AwsAccountId

BODY json

{
  "IngestionType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId" {:content-type :json
                                                                                                               :form-params {:IngestionType ""}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"IngestionType\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId"),
    Content = new StringContent("{\n  \"IngestionType\": \"\"\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}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"IngestionType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId"

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

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

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

}

PUT /baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 25

{
  "IngestionType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"IngestionType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"IngestionType\": \"\"\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  \"IngestionType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId")
  .header("content-type", "application/json")
  .body("{\n  \"IngestionType\": \"\"\n}")
  .asString();

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

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

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

xhr.open('PUT', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId',
  headers: {'content-type': 'application/json'},
  data: {IngestionType: ''}
};

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"IngestionType":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "IngestionType": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"IngestionType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId',
  headers: {
    '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({IngestionType: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId',
  headers: {'content-type': 'application/json'},
  body: {IngestionType: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId');

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

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

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId',
  headers: {'content-type': 'application/json'},
  data: {IngestionType: ''}
};

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

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"IngestionType":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"IngestionType": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"IngestionType\": \"\"\n}" in

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

 "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'IngestionType' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId', [
  'body' => '{
  "IngestionType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId');
$request->setMethod(HTTP_METH_PUT);

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

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

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

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

append(json_encode([
  'IngestionType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "IngestionType": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "IngestionType": ""
}'

import http.client

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

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

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId"

payload = { "IngestionType": "" }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId"

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

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"IngestionType\": \"\"\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.put('/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId') do |req|
  req.body = "{\n  \"IngestionType\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId";

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

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId \
  --header 'content-type: application/json' \
  --data '{
  "IngestionType": ""
}'

echo '{
  "IngestionType": ""
}' |  \
  http PUT {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "IngestionType": ""\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["IngestionType": ""] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

POST CreateNamespace

{{baseUrl}}/accounts/:AwsAccountId

QUERY PARAMS

AwsAccountId

BODY json

{
  "Namespace": "",
  "IdentityStore": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Namespace\": \"\",\n  \"IdentityStore\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/accounts/:AwsAccountId" {:content-type :json
                                                                   :form-params {:Namespace ""
                                                                                 :IdentityStore ""
                                                                                 :Tags [{:Key ""
                                                                                         :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Namespace\": \"\",\n  \"IdentityStore\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/accounts/:AwsAccountId"),
    Content = new StringContent("{\n  \"Namespace\": \"\",\n  \"IdentityStore\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/accounts/:AwsAccountId");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Namespace\": \"\",\n  \"IdentityStore\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId"

	payload := strings.NewReader("{\n  \"Namespace\": \"\",\n  \"IdentityStore\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

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

	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/accounts/:AwsAccountId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 108

{
  "Namespace": "",
  "IdentityStore": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:AwsAccountId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Namespace\": \"\",\n  \"IdentityStore\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Namespace\": \"\",\n  \"IdentityStore\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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  \"Namespace\": \"\",\n  \"IdentityStore\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:AwsAccountId")
  .header("content-type", "application/json")
  .body("{\n  \"Namespace\": \"\",\n  \"IdentityStore\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  Namespace: '',
  IdentityStore: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/accounts/:AwsAccountId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId',
  headers: {'content-type': 'application/json'},
  data: {Namespace: '', IdentityStore: '', Tags: [{Key: '', Value: ''}]}
};

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

const url = '{{baseUrl}}/accounts/:AwsAccountId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Namespace":"","IdentityStore":"","Tags":[{"Key":"","Value":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Namespace": "",\n  "IdentityStore": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\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  \"Namespace\": \"\",\n  \"IdentityStore\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId")
  .post(body)
  .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/accounts/:AwsAccountId',
  headers: {
    '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({Namespace: '', IdentityStore: '', Tags: [{Key: '', Value: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId',
  headers: {'content-type': 'application/json'},
  body: {Namespace: '', IdentityStore: '', Tags: [{Key: '', Value: ''}]},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/accounts/:AwsAccountId');

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

req.type('json');
req.send({
  Namespace: '',
  IdentityStore: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId',
  headers: {'content-type': 'application/json'},
  data: {Namespace: '', IdentityStore: '', Tags: [{Key: '', Value: ''}]}
};

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

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

const url = '{{baseUrl}}/accounts/:AwsAccountId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Namespace":"","IdentityStore":"","Tags":[{"Key":"","Value":""}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Namespace": @"",
                              @"IdentityStore": @"",
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId"]
                                                       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}}/accounts/:AwsAccountId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Namespace\": \"\",\n  \"IdentityStore\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/accounts/:AwsAccountId",
  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([
    'Namespace' => '',
    'IdentityStore' => '',
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/accounts/:AwsAccountId', [
  'body' => '{
  "Namespace": "",
  "IdentityStore": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Namespace' => '',
  'IdentityStore' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'Namespace' => '',
  'IdentityStore' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Namespace": "",
  "IdentityStore": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Namespace": "",
  "IdentityStore": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"Namespace\": \"\",\n  \"IdentityStore\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

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

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

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

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId"

payload = {
    "Namespace": "",
    "IdentityStore": "",
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId"

payload <- "{\n  \"Namespace\": \"\",\n  \"IdentityStore\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Namespace\": \"\",\n  \"IdentityStore\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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/accounts/:AwsAccountId') do |req|
  req.body = "{\n  \"Namespace\": \"\",\n  \"IdentityStore\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId";

    let payload = json!({
        "Namespace": "",
        "IdentityStore": "",
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/accounts/:AwsAccountId \
  --header 'content-type: application/json' \
  --data '{
  "Namespace": "",
  "IdentityStore": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

echo '{
  "Namespace": "",
  "IdentityStore": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/accounts/:AwsAccountId \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Namespace": "",\n  "IdentityStore": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Namespace": "",
  "IdentityStore": "",
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

POST CreateRefreshSchedule

{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules

QUERY PARAMS

DataSetId

AwsAccountId

BODY json

{
  "Schedule": {
    "ScheduleId": "",
    "ScheduleFrequency": "",
    "StartAfterDateTime": "",
    "RefreshType": "",
    "Arn": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules" {:content-type :json
                                                                                                          :form-params {:Schedule {:ScheduleId ""
                                                                                                                                   :ScheduleFrequency ""
                                                                                                                                   :StartAfterDateTime ""
                                                                                                                                   :RefreshType ""
                                                                                                                                   :Arn ""}}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\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}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules"),
    Content = new StringContent("{\n  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\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}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules"

	payload := strings.NewReader("{\n  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\n  }\n}")

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

	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/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 141

{
  "Schedule": {
    "ScheduleId": "",
    "ScheduleFrequency": "",
    "StartAfterDateTime": "",
    "RefreshType": "",
    "Arn": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\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  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules")
  .header("content-type", "application/json")
  .body("{\n  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  Schedule: {
    ScheduleId: '',
    ScheduleFrequency: '',
    StartAfterDateTime: '',
    RefreshType: '',
    Arn: ''
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules',
  headers: {'content-type': 'application/json'},
  data: {
    Schedule: {
      ScheduleId: '',
      ScheduleFrequency: '',
      StartAfterDateTime: '',
      RefreshType: '',
      Arn: ''
    }
  }
};

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Schedule":{"ScheduleId":"","ScheduleFrequency":"","StartAfterDateTime":"","RefreshType":"","Arn":""}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Schedule": {\n    "ScheduleId": "",\n    "ScheduleFrequency": "",\n    "StartAfterDateTime": "",\n    "RefreshType": "",\n    "Arn": ""\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  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules")
  .post(body)
  .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/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules',
  headers: {
    '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({
  Schedule: {
    ScheduleId: '',
    ScheduleFrequency: '',
    StartAfterDateTime: '',
    RefreshType: '',
    Arn: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules',
  headers: {'content-type': 'application/json'},
  body: {
    Schedule: {
      ScheduleId: '',
      ScheduleFrequency: '',
      StartAfterDateTime: '',
      RefreshType: '',
      Arn: ''
    }
  },
  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}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules');

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

req.type('json');
req.send({
  Schedule: {
    ScheduleId: '',
    ScheduleFrequency: '',
    StartAfterDateTime: '',
    RefreshType: '',
    Arn: ''
  }
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules',
  headers: {'content-type': 'application/json'},
  data: {
    Schedule: {
      ScheduleId: '',
      ScheduleFrequency: '',
      StartAfterDateTime: '',
      RefreshType: '',
      Arn: ''
    }
  }
};

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

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Schedule":{"ScheduleId":"","ScheduleFrequency":"","StartAfterDateTime":"","RefreshType":"","Arn":""}}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Schedule": @{ @"ScheduleId": @"", @"ScheduleFrequency": @"", @"StartAfterDateTime": @"", @"RefreshType": @"", @"Arn": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules"]
                                                       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}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules",
  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([
    'Schedule' => [
        'ScheduleId' => '',
        'ScheduleFrequency' => '',
        'StartAfterDateTime' => '',
        'RefreshType' => '',
        'Arn' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules', [
  'body' => '{
  "Schedule": {
    "ScheduleId": "",
    "ScheduleFrequency": "",
    "StartAfterDateTime": "",
    "RefreshType": "",
    "Arn": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Schedule' => [
    'ScheduleId' => '',
    'ScheduleFrequency' => '',
    'StartAfterDateTime' => '',
    'RefreshType' => '',
    'Arn' => ''
  ]
]));

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

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

append(json_encode([
  'Schedule' => [
    'ScheduleId' => '',
    'ScheduleFrequency' => '',
    'StartAfterDateTime' => '',
    'RefreshType' => '',
    'Arn' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Schedule": {
    "ScheduleId": "",
    "ScheduleFrequency": "",
    "StartAfterDateTime": "",
    "RefreshType": "",
    "Arn": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Schedule": {
    "ScheduleId": "",
    "ScheduleFrequency": "",
    "StartAfterDateTime": "",
    "RefreshType": "",
    "Arn": ""
  }
}'

import http.client

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

payload = "{\n  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules", payload, headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules"

payload = { "Schedule": {
        "ScheduleId": "",
        "ScheduleFrequency": "",
        "StartAfterDateTime": "",
        "RefreshType": "",
        "Arn": ""
    } }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules"

payload <- "{\n  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\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/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules') do |req|
  req.body = "{\n  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules";

    let payload = json!({"Schedule": json!({
            "ScheduleId": "",
            "ScheduleFrequency": "",
            "StartAfterDateTime": "",
            "RefreshType": "",
            "Arn": ""
        })});

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules \
  --header 'content-type: application/json' \
  --data '{
  "Schedule": {
    "ScheduleId": "",
    "ScheduleFrequency": "",
    "StartAfterDateTime": "",
    "RefreshType": "",
    "Arn": ""
  }
}'

echo '{
  "Schedule": {
    "ScheduleId": "",
    "ScheduleFrequency": "",
    "StartAfterDateTime": "",
    "RefreshType": "",
    "Arn": ""
  }
}' |  \
  http POST {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Schedule": {\n    "ScheduleId": "",\n    "ScheduleFrequency": "",\n    "StartAfterDateTime": "",\n    "RefreshType": "",\n    "Arn": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["Schedule": [
    "ScheduleId": "",
    "ScheduleFrequency": "",
    "StartAfterDateTime": "",
    "RefreshType": "",
    "Arn": ""
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

POST CreateTemplate

{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId

QUERY PARAMS

AwsAccountId

TemplateId

BODY json

{
  "Name": "",
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "SourceEntity": {
    "SourceAnalysis": "",
    "SourceTemplate": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "VersionDescription": "",
  "Definition": {
    "DataSetConfigurations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId");

struct curl_slist *headers = NULL;
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  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId" {:content-type :json
                                                                                         :form-params {:Name ""
                                                                                                       :Permissions [{:Principal ""
                                                                                                                      :Actions ""}]
                                                                                                       :SourceEntity {:SourceAnalysis ""
                                                                                                                      :SourceTemplate ""}
                                                                                                       :Tags [{:Key ""
                                                                                                               :Value ""}]
                                                                                                       :VersionDescription ""
                                                                                                       :Definition {:DataSetConfigurations ""
                                                                                                                    :Sheets ""
                                                                                                                    :CalculatedFields ""
                                                                                                                    :ParameterDeclarations ""
                                                                                                                    :FilterGroups ""
                                                                                                                    :ColumnConfigurations ""
                                                                                                                    :AnalysisDefaults {:DefaultNewSheetConfiguration ""}}}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\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}}/accounts/:AwsAccountId/templates/:TemplateId"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\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}}/accounts/:AwsAccountId/templates/:TemplateId");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}")

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

	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/accounts/:AwsAccountId/templates/:TemplateId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 527

{
  "Name": "",
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "SourceEntity": {
    "SourceAnalysis": "",
    "SourceTemplate": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "VersionDescription": "",
  "Definition": {
    "DataSetConfigurations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\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  \"Name\": \"\",\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Permissions: [
    {
      Principal: '',
      Actions: ''
    }
  ],
  SourceEntity: {
    SourceAnalysis: '',
    SourceTemplate: ''
  },
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  VersionDescription: '',
  Definition: {
    DataSetConfigurations: '',
    Sheets: '',
    CalculatedFields: '',
    ParameterDeclarations: '',
    FilterGroups: '',
    ColumnConfigurations: '',
    AnalysisDefaults: {
      DefaultNewSheetConfiguration: ''
    }
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Permissions: [{Principal: '', Actions: ''}],
    SourceEntity: {SourceAnalysis: '', SourceTemplate: ''},
    Tags: [{Key: '', Value: ''}],
    VersionDescription: '',
    Definition: {
      DataSetConfigurations: '',
      Sheets: '',
      CalculatedFields: '',
      ParameterDeclarations: '',
      FilterGroups: '',
      ColumnConfigurations: '',
      AnalysisDefaults: {DefaultNewSheetConfiguration: ''}
    }
  }
};

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Permissions":[{"Principal":"","Actions":""}],"SourceEntity":{"SourceAnalysis":"","SourceTemplate":""},"Tags":[{"Key":"","Value":""}],"VersionDescription":"","Definition":{"DataSetConfigurations":"","Sheets":"","CalculatedFields":"","ParameterDeclarations":"","FilterGroups":"","ColumnConfigurations":"","AnalysisDefaults":{"DefaultNewSheetConfiguration":""}}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Permissions": [\n    {\n      "Principal": "",\n      "Actions": ""\n    }\n  ],\n  "SourceEntity": {\n    "SourceAnalysis": "",\n    "SourceTemplate": ""\n  },\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "VersionDescription": "",\n  "Definition": {\n    "DataSetConfigurations": "",\n    "Sheets": "",\n    "CalculatedFields": "",\n    "ParameterDeclarations": "",\n    "FilterGroups": "",\n    "ColumnConfigurations": "",\n    "AnalysisDefaults": {\n      "DefaultNewSheetConfiguration": ""\n    }\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  \"Name\": \"\",\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId")
  .post(body)
  .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/accounts/:AwsAccountId/templates/:TemplateId',
  headers: {
    '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: '',
  Permissions: [{Principal: '', Actions: ''}],
  SourceEntity: {SourceAnalysis: '', SourceTemplate: ''},
  Tags: [{Key: '', Value: ''}],
  VersionDescription: '',
  Definition: {
    DataSetConfigurations: '',
    Sheets: '',
    CalculatedFields: '',
    ParameterDeclarations: '',
    FilterGroups: '',
    ColumnConfigurations: '',
    AnalysisDefaults: {DefaultNewSheetConfiguration: ''}
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId',
  headers: {'content-type': 'application/json'},
  body: {
    Name: '',
    Permissions: [{Principal: '', Actions: ''}],
    SourceEntity: {SourceAnalysis: '', SourceTemplate: ''},
    Tags: [{Key: '', Value: ''}],
    VersionDescription: '',
    Definition: {
      DataSetConfigurations: '',
      Sheets: '',
      CalculatedFields: '',
      ParameterDeclarations: '',
      FilterGroups: '',
      ColumnConfigurations: '',
      AnalysisDefaults: {DefaultNewSheetConfiguration: ''}
    }
  },
  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}}/accounts/:AwsAccountId/templates/:TemplateId');

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

req.type('json');
req.send({
  Name: '',
  Permissions: [
    {
      Principal: '',
      Actions: ''
    }
  ],
  SourceEntity: {
    SourceAnalysis: '',
    SourceTemplate: ''
  },
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  VersionDescription: '',
  Definition: {
    DataSetConfigurations: '',
    Sheets: '',
    CalculatedFields: '',
    ParameterDeclarations: '',
    FilterGroups: '',
    ColumnConfigurations: '',
    AnalysisDefaults: {
      DefaultNewSheetConfiguration: ''
    }
  }
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Permissions: [{Principal: '', Actions: ''}],
    SourceEntity: {SourceAnalysis: '', SourceTemplate: ''},
    Tags: [{Key: '', Value: ''}],
    VersionDescription: '',
    Definition: {
      DataSetConfigurations: '',
      Sheets: '',
      CalculatedFields: '',
      ParameterDeclarations: '',
      FilterGroups: '',
      ColumnConfigurations: '',
      AnalysisDefaults: {DefaultNewSheetConfiguration: ''}
    }
  }
};

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

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Permissions":[{"Principal":"","Actions":""}],"SourceEntity":{"SourceAnalysis":"","SourceTemplate":""},"Tags":[{"Key":"","Value":""}],"VersionDescription":"","Definition":{"DataSetConfigurations":"","Sheets":"","CalculatedFields":"","ParameterDeclarations":"","FilterGroups":"","ColumnConfigurations":"","AnalysisDefaults":{"DefaultNewSheetConfiguration":""}}}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"Permissions": @[ @{ @"Principal": @"", @"Actions": @"" } ],
                              @"SourceEntity": @{ @"SourceAnalysis": @"", @"SourceTemplate": @"" },
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"VersionDescription": @"",
                              @"Definition": @{ @"DataSetConfigurations": @"", @"Sheets": @"", @"CalculatedFields": @"", @"ParameterDeclarations": @"", @"FilterGroups": @"", @"ColumnConfigurations": @"", @"AnalysisDefaults": @{ @"DefaultNewSheetConfiguration": @"" } } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId"]
                                                       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}}/accounts/:AwsAccountId/templates/:TemplateId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}" in

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

 "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId",
  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' => '',
    'Permissions' => [
        [
                'Principal' => '',
                'Actions' => ''
        ]
    ],
    'SourceEntity' => [
        'SourceAnalysis' => '',
        'SourceTemplate' => ''
    ],
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'VersionDescription' => '',
    'Definition' => [
        'DataSetConfigurations' => '',
        'Sheets' => '',
        'CalculatedFields' => '',
        'ParameterDeclarations' => '',
        'FilterGroups' => '',
        'ColumnConfigurations' => '',
        'AnalysisDefaults' => [
                'DefaultNewSheetConfiguration' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId', [
  'body' => '{
  "Name": "",
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "SourceEntity": {
    "SourceAnalysis": "",
    "SourceTemplate": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "VersionDescription": "",
  "Definition": {
    "DataSetConfigurations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Permissions' => [
    [
        'Principal' => '',
        'Actions' => ''
    ]
  ],
  'SourceEntity' => [
    'SourceAnalysis' => '',
    'SourceTemplate' => ''
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'VersionDescription' => '',
  'Definition' => [
    'DataSetConfigurations' => '',
    'Sheets' => '',
    'CalculatedFields' => '',
    'ParameterDeclarations' => '',
    'FilterGroups' => '',
    'ColumnConfigurations' => '',
    'AnalysisDefaults' => [
        'DefaultNewSheetConfiguration' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'Name' => '',
  'Permissions' => [
    [
        'Principal' => '',
        'Actions' => ''
    ]
  ],
  'SourceEntity' => [
    'SourceAnalysis' => '',
    'SourceTemplate' => ''
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'VersionDescription' => '',
  'Definition' => [
    'DataSetConfigurations' => '',
    'Sheets' => '',
    'CalculatedFields' => '',
    'ParameterDeclarations' => '',
    'FilterGroups' => '',
    'ColumnConfigurations' => '',
    'AnalysisDefaults' => [
        'DefaultNewSheetConfiguration' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "SourceEntity": {
    "SourceAnalysis": "",
    "SourceTemplate": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "VersionDescription": "",
  "Definition": {
    "DataSetConfigurations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "SourceEntity": {
    "SourceAnalysis": "",
    "SourceTemplate": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "VersionDescription": "",
  "Definition": {
    "DataSetConfigurations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/accounts/:AwsAccountId/templates/:TemplateId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId"

payload = {
    "Name": "",
    "Permissions": [
        {
            "Principal": "",
            "Actions": ""
        }
    ],
    "SourceEntity": {
        "SourceAnalysis": "",
        "SourceTemplate": ""
    },
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "VersionDescription": "",
    "Definition": {
        "DataSetConfigurations": "",
        "Sheets": "",
        "CalculatedFields": "",
        "ParameterDeclarations": "",
        "FilterGroups": "",
        "ColumnConfigurations": "",
        "AnalysisDefaults": { "DefaultNewSheetConfiguration": "" }
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId"

payload <- "{\n  \"Name\": \"\",\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\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/accounts/:AwsAccountId/templates/:TemplateId') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"VersionDescription\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId";

    let payload = json!({
        "Name": "",
        "Permissions": (
            json!({
                "Principal": "",
                "Actions": ""
            })
        ),
        "SourceEntity": json!({
            "SourceAnalysis": "",
            "SourceTemplate": ""
        }),
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "VersionDescription": "",
        "Definition": json!({
            "DataSetConfigurations": "",
            "Sheets": "",
            "CalculatedFields": "",
            "ParameterDeclarations": "",
            "FilterGroups": "",
            "ColumnConfigurations": "",
            "AnalysisDefaults": json!({"DefaultNewSheetConfiguration": ""})
        })
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId \
  --header 'content-type: application/json' \
  --data '{
  "Name": "",
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "SourceEntity": {
    "SourceAnalysis": "",
    "SourceTemplate": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "VersionDescription": "",
  "Definition": {
    "DataSetConfigurations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}'

echo '{
  "Name": "",
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "SourceEntity": {
    "SourceAnalysis": "",
    "SourceTemplate": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "VersionDescription": "",
  "Definition": {
    "DataSetConfigurations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}' |  \
  http POST {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Permissions": [\n    {\n      "Principal": "",\n      "Actions": ""\n    }\n  ],\n  "SourceEntity": {\n    "SourceAnalysis": "",\n    "SourceTemplate": ""\n  },\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "VersionDescription": "",\n  "Definition": {\n    "DataSetConfigurations": "",\n    "Sheets": "",\n    "CalculatedFields": "",\n    "ParameterDeclarations": "",\n    "FilterGroups": "",\n    "ColumnConfigurations": "",\n    "AnalysisDefaults": {\n      "DefaultNewSheetConfiguration": ""\n    }\n  }\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "Permissions": [
    [
      "Principal": "",
      "Actions": ""
    ]
  ],
  "SourceEntity": [
    "SourceAnalysis": "",
    "SourceTemplate": ""
  ],
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "VersionDescription": "",
  "Definition": [
    "DataSetConfigurations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": ["DefaultNewSheetConfiguration": ""]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

POST CreateTemplateAlias

{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName

QUERY PARAMS

AwsAccountId

TemplateId

AliasName

BODY json

{
  "TemplateVersionNumber": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName" {:content-type :json
                                                                                                            :form-params {:TemplateVersionNumber 0}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"TemplateVersionNumber\": 0\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}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName"),
    Content = new StringContent("{\n  \"TemplateVersionNumber\": 0\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}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TemplateVersionNumber\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName"

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

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

	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/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 32

{
  "TemplateVersionNumber": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TemplateVersionNumber\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TemplateVersionNumber\": 0\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  \"TemplateVersionNumber\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName")
  .header("content-type", "application/json")
  .body("{\n  \"TemplateVersionNumber\": 0\n}")
  .asString();

const data = JSON.stringify({
  TemplateVersionNumber: 0
});

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

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

xhr.open('POST', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName',
  headers: {'content-type': 'application/json'},
  data: {TemplateVersionNumber: 0}
};

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"TemplateVersionNumber":0}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TemplateVersionNumber": 0\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TemplateVersionNumber\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName")
  .post(body)
  .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/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName',
  headers: {
    '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({TemplateVersionNumber: 0}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName',
  headers: {'content-type': 'application/json'},
  body: {TemplateVersionNumber: 0},
  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}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName');

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

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

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName',
  headers: {'content-type': 'application/json'},
  data: {TemplateVersionNumber: 0}
};

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

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"TemplateVersionNumber":0}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"TemplateVersionNumber": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName"]
                                                       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}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"TemplateVersionNumber\": 0\n}" in

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

 "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName",
  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([
    'TemplateVersionNumber' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName', [
  'body' => '{
  "TemplateVersionNumber": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'TemplateVersionNumber' => 0
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TemplateVersionNumber": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TemplateVersionNumber": 0
}'

import http.client

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

payload = "{\n  \"TemplateVersionNumber\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName", payload, headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName"

payload = { "TemplateVersionNumber": 0 }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName"

payload <- "{\n  \"TemplateVersionNumber\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"TemplateVersionNumber\": 0\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/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName') do |req|
  req.body = "{\n  \"TemplateVersionNumber\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName";

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName \
  --header 'content-type: application/json' \
  --data '{
  "TemplateVersionNumber": 0
}'

echo '{
  "TemplateVersionNumber": 0
}' |  \
  http POST {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "TemplateVersionNumber": 0\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["TemplateVersionNumber": 0] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

POST CreateTheme

{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId

QUERY PARAMS

AwsAccountId

ThemeId

BODY json

{
  "Name": "",
  "BaseThemeId": "",
  "VersionDescription": "",
  "Configuration": {
    "DataColorPalette": "",
    "UIColorPalette": "",
    "Sheet": "",
    "Typography": {
      "FontFamilies": ""
    }
  },
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId");

struct curl_slist *headers = NULL;
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  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId" {:content-type :json
                                                                                   :form-params {:Name ""
                                                                                                 :BaseThemeId ""
                                                                                                 :VersionDescription ""
                                                                                                 :Configuration {:DataColorPalette ""
                                                                                                                 :UIColorPalette ""
                                                                                                                 :Sheet ""
                                                                                                                 :Typography {:FontFamilies ""}}
                                                                                                 :Permissions [{:Principal ""
                                                                                                                :Actions ""}]
                                                                                                 :Tags [{:Key ""
                                                                                                         :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/accounts/:AwsAccountId/themes/:ThemeId"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/accounts/:AwsAccountId/themes/:ThemeId");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

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

	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/accounts/:AwsAccountId/themes/:ThemeId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 356

{
  "Name": "",
  "BaseThemeId": "",
  "VersionDescription": "",
  "Configuration": {
    "DataColorPalette": "",
    "UIColorPalette": "",
    "Sheet": "",
    "Typography": {
      "FontFamilies": ""
    }
  },
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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  \"Name\": \"\",\n  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  BaseThemeId: '',
  VersionDescription: '',
  Configuration: {
    DataColorPalette: '',
    UIColorPalette: '',
    Sheet: '',
    Typography: {
      FontFamilies: ''
    }
  },
  Permissions: [
    {
      Principal: '',
      Actions: ''
    }
  ],
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    BaseThemeId: '',
    VersionDescription: '',
    Configuration: {
      DataColorPalette: '',
      UIColorPalette: '',
      Sheet: '',
      Typography: {FontFamilies: ''}
    },
    Permissions: [{Principal: '', Actions: ''}],
    Tags: [{Key: '', Value: ''}]
  }
};

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","BaseThemeId":"","VersionDescription":"","Configuration":{"DataColorPalette":"","UIColorPalette":"","Sheet":"","Typography":{"FontFamilies":""}},"Permissions":[{"Principal":"","Actions":""}],"Tags":[{"Key":"","Value":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "BaseThemeId": "",\n  "VersionDescription": "",\n  "Configuration": {\n    "DataColorPalette": "",\n    "UIColorPalette": "",\n    "Sheet": "",\n    "Typography": {\n      "FontFamilies": ""\n    }\n  },\n  "Permissions": [\n    {\n      "Principal": "",\n      "Actions": ""\n    }\n  ],\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\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  \"Name\": \"\",\n  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId")
  .post(body)
  .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/accounts/:AwsAccountId/themes/:ThemeId',
  headers: {
    '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: '',
  BaseThemeId: '',
  VersionDescription: '',
  Configuration: {
    DataColorPalette: '',
    UIColorPalette: '',
    Sheet: '',
    Typography: {FontFamilies: ''}
  },
  Permissions: [{Principal: '', Actions: ''}],
  Tags: [{Key: '', Value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId',
  headers: {'content-type': 'application/json'},
  body: {
    Name: '',
    BaseThemeId: '',
    VersionDescription: '',
    Configuration: {
      DataColorPalette: '',
      UIColorPalette: '',
      Sheet: '',
      Typography: {FontFamilies: ''}
    },
    Permissions: [{Principal: '', Actions: ''}],
    Tags: [{Key: '', Value: ''}]
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId');

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

req.type('json');
req.send({
  Name: '',
  BaseThemeId: '',
  VersionDescription: '',
  Configuration: {
    DataColorPalette: '',
    UIColorPalette: '',
    Sheet: '',
    Typography: {
      FontFamilies: ''
    }
  },
  Permissions: [
    {
      Principal: '',
      Actions: ''
    }
  ],
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    BaseThemeId: '',
    VersionDescription: '',
    Configuration: {
      DataColorPalette: '',
      UIColorPalette: '',
      Sheet: '',
      Typography: {FontFamilies: ''}
    },
    Permissions: [{Principal: '', Actions: ''}],
    Tags: [{Key: '', Value: ''}]
  }
};

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

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","BaseThemeId":"","VersionDescription":"","Configuration":{"DataColorPalette":"","UIColorPalette":"","Sheet":"","Typography":{"FontFamilies":""}},"Permissions":[{"Principal":"","Actions":""}],"Tags":[{"Key":"","Value":""}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"BaseThemeId": @"",
                              @"VersionDescription": @"",
                              @"Configuration": @{ @"DataColorPalette": @"", @"UIColorPalette": @"", @"Sheet": @"", @"Typography": @{ @"FontFamilies": @"" } },
                              @"Permissions": @[ @{ @"Principal": @"", @"Actions": @"" } ],
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId"]
                                                       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}}/accounts/:AwsAccountId/themes/:ThemeId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId",
  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' => '',
    'BaseThemeId' => '',
    'VersionDescription' => '',
    'Configuration' => [
        'DataColorPalette' => '',
        'UIColorPalette' => '',
        'Sheet' => '',
        'Typography' => [
                'FontFamilies' => ''
        ]
    ],
    'Permissions' => [
        [
                'Principal' => '',
                'Actions' => ''
        ]
    ],
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId', [
  'body' => '{
  "Name": "",
  "BaseThemeId": "",
  "VersionDescription": "",
  "Configuration": {
    "DataColorPalette": "",
    "UIColorPalette": "",
    "Sheet": "",
    "Typography": {
      "FontFamilies": ""
    }
  },
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'BaseThemeId' => '',
  'VersionDescription' => '',
  'Configuration' => [
    'DataColorPalette' => '',
    'UIColorPalette' => '',
    'Sheet' => '',
    'Typography' => [
        'FontFamilies' => ''
    ]
  ],
  'Permissions' => [
    [
        'Principal' => '',
        'Actions' => ''
    ]
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'Name' => '',
  'BaseThemeId' => '',
  'VersionDescription' => '',
  'Configuration' => [
    'DataColorPalette' => '',
    'UIColorPalette' => '',
    'Sheet' => '',
    'Typography' => [
        'FontFamilies' => ''
    ]
  ],
  'Permissions' => [
    [
        'Principal' => '',
        'Actions' => ''
    ]
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "BaseThemeId": "",
  "VersionDescription": "",
  "Configuration": {
    "DataColorPalette": "",
    "UIColorPalette": "",
    "Sheet": "",
    "Typography": {
      "FontFamilies": ""
    }
  },
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "BaseThemeId": "",
  "VersionDescription": "",
  "Configuration": {
    "DataColorPalette": "",
    "UIColorPalette": "",
    "Sheet": "",
    "Typography": {
      "FontFamilies": ""
    }
  },
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/accounts/:AwsAccountId/themes/:ThemeId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId"

payload = {
    "Name": "",
    "BaseThemeId": "",
    "VersionDescription": "",
    "Configuration": {
        "DataColorPalette": "",
        "UIColorPalette": "",
        "Sheet": "",
        "Typography": { "FontFamilies": "" }
    },
    "Permissions": [
        {
            "Principal": "",
            "Actions": ""
        }
    ],
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId"

payload <- "{\n  \"Name\": \"\",\n  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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/accounts/:AwsAccountId/themes/:ThemeId') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\n  },\n  \"Permissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId";

    let payload = json!({
        "Name": "",
        "BaseThemeId": "",
        "VersionDescription": "",
        "Configuration": json!({
            "DataColorPalette": "",
            "UIColorPalette": "",
            "Sheet": "",
            "Typography": json!({"FontFamilies": ""})
        }),
        "Permissions": (
            json!({
                "Principal": "",
                "Actions": ""
            })
        ),
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId \
  --header 'content-type: application/json' \
  --data '{
  "Name": "",
  "BaseThemeId": "",
  "VersionDescription": "",
  "Configuration": {
    "DataColorPalette": "",
    "UIColorPalette": "",
    "Sheet": "",
    "Typography": {
      "FontFamilies": ""
    }
  },
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

echo '{
  "Name": "",
  "BaseThemeId": "",
  "VersionDescription": "",
  "Configuration": {
    "DataColorPalette": "",
    "UIColorPalette": "",
    "Sheet": "",
    "Typography": {
      "FontFamilies": ""
    }
  },
  "Permissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "BaseThemeId": "",\n  "VersionDescription": "",\n  "Configuration": {\n    "DataColorPalette": "",\n    "UIColorPalette": "",\n    "Sheet": "",\n    "Typography": {\n      "FontFamilies": ""\n    }\n  },\n  "Permissions": [\n    {\n      "Principal": "",\n      "Actions": ""\n    }\n  ],\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "BaseThemeId": "",
  "VersionDescription": "",
  "Configuration": [
    "DataColorPalette": "",
    "UIColorPalette": "",
    "Sheet": "",
    "Typography": ["FontFamilies": ""]
  ],
  "Permissions": [
    [
      "Principal": "",
      "Actions": ""
    ]
  ],
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

POST CreateThemeAlias

{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName

QUERY PARAMS

AwsAccountId

ThemeId

AliasName

BODY json

{
  "ThemeVersionNumber": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName" {:content-type :json
                                                                                                      :form-params {:ThemeVersionNumber 0}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ThemeVersionNumber\": 0\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}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName"),
    Content = new StringContent("{\n  \"ThemeVersionNumber\": 0\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}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ThemeVersionNumber\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName"

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

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

	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/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 29

{
  "ThemeVersionNumber": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ThemeVersionNumber\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ThemeVersionNumber\": 0\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  \"ThemeVersionNumber\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName")
  .header("content-type", "application/json")
  .body("{\n  \"ThemeVersionNumber\": 0\n}")
  .asString();

const data = JSON.stringify({
  ThemeVersionNumber: 0
});

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

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

xhr.open('POST', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName',
  headers: {'content-type': 'application/json'},
  data: {ThemeVersionNumber: 0}
};

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ThemeVersionNumber":0}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ThemeVersionNumber": 0\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ThemeVersionNumber\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName")
  .post(body)
  .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/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName',
  headers: {
    '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({ThemeVersionNumber: 0}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName',
  headers: {'content-type': 'application/json'},
  body: {ThemeVersionNumber: 0},
  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}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName');

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

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

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName',
  headers: {'content-type': 'application/json'},
  data: {ThemeVersionNumber: 0}
};

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

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ThemeVersionNumber":0}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ThemeVersionNumber": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName"]
                                                       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}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ThemeVersionNumber\": 0\n}" in

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

 "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName",
  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([
    'ThemeVersionNumber' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName', [
  'body' => '{
  "ThemeVersionNumber": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'ThemeVersionNumber' => 0
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ThemeVersionNumber": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ThemeVersionNumber": 0
}'

import http.client

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

payload = "{\n  \"ThemeVersionNumber\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName", payload, headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName"

payload = { "ThemeVersionNumber": 0 }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName"

payload <- "{\n  \"ThemeVersionNumber\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"ThemeVersionNumber\": 0\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/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName') do |req|
  req.body = "{\n  \"ThemeVersionNumber\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName";

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName \
  --header 'content-type: application/json' \
  --data '{
  "ThemeVersionNumber": 0
}'

echo '{
  "ThemeVersionNumber": 0
}' |  \
  http POST {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "ThemeVersionNumber": 0\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["ThemeVersionNumber": 0] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName")! 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()

DELETE DeleteAccountCustomization

{{baseUrl}}/accounts/:AwsAccountId/customizations

QUERY PARAMS

AwsAccountId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/customizations");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/accounts/:AwsAccountId/customizations")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/customizations"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/customizations"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/customizations");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/customizations"

	req, _ := http.NewRequest("DELETE", url, nil)

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

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

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

}

DELETE /baseUrl/accounts/:AwsAccountId/customizations HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/accounts/:AwsAccountId/customizations")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/customizations"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/customizations")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/accounts/:AwsAccountId/customizations")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/customizations');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/customizations'
};

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/customizations';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/customizations',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/customizations")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/customizations',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/customizations'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/customizations');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/customizations'
};

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

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/customizations';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/customizations"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/customizations" in

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

 "{{baseUrl}}/accounts/:AwsAccountId/customizations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/customizations');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/customizations');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/customizations');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/customizations' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/customizations' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/accounts/:AwsAccountId/customizations")

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

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

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/customizations"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/customizations"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/customizations")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/accounts/:AwsAccountId/customizations') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/customizations";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/accounts/:AwsAccountId/customizations

http DELETE {{baseUrl}}/accounts/:AwsAccountId/customizations

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/customizations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/customizations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

DELETE DeleteAccountSubscription

{{baseUrl}}/account/:AwsAccountId

QUERY PARAMS

AwsAccountId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/:AwsAccountId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/account/:AwsAccountId")

require "http/client"

url = "{{baseUrl}}/account/:AwsAccountId"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/account/:AwsAccountId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/:AwsAccountId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/:AwsAccountId"

	req, _ := http.NewRequest("DELETE", url, nil)

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

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

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

}

DELETE /baseUrl/account/:AwsAccountId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/account/:AwsAccountId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/:AwsAccountId"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/:AwsAccountId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/account/:AwsAccountId")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/account/:AwsAccountId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/account/:AwsAccountId'};

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

const url = '{{baseUrl}}/account/:AwsAccountId';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/:AwsAccountId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/:AwsAccountId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/:AwsAccountId',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/account/:AwsAccountId'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/account/:AwsAccountId');

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

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

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

const options = {method: 'DELETE', url: '{{baseUrl}}/account/:AwsAccountId'};

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

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

const url = '{{baseUrl}}/account/:AwsAccountId';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/:AwsAccountId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/:AwsAccountId" in

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

 "{{baseUrl}}/account/:AwsAccountId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/account/:AwsAccountId');

echo $response->getBody();

setUrl('{{baseUrl}}/account/:AwsAccountId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/account/:AwsAccountId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/:AwsAccountId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/:AwsAccountId' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/account/:AwsAccountId")

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

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

import requests

url = "{{baseUrl}}/account/:AwsAccountId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/:AwsAccountId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/:AwsAccountId")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/account/:AwsAccountId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/:AwsAccountId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/account/:AwsAccountId

http DELETE {{baseUrl}}/account/:AwsAccountId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/account/:AwsAccountId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/:AwsAccountId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

DELETE DeleteAnalysis

{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId

QUERY PARAMS

AwsAccountId

AnalysisId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId"

	req, _ := http.NewRequest("DELETE", url, nil)

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

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

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

}

DELETE /baseUrl/accounts/:AwsAccountId/analyses/:AnalysisId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId'
};

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/analyses/:AnalysisId',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId'
};

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

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

const url = '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId" in

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

 "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/accounts/:AwsAccountId/analyses/:AnalysisId")

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

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

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/accounts/:AwsAccountId/analyses/:AnalysisId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId

http DELETE {{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

DELETE DeleteDashboard

{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId

QUERY PARAMS

AwsAccountId

DashboardId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId"

	req, _ := http.NewRequest("DELETE", url, nil)

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

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId

http DELETE {{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteDataSet

{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId

QUERY PARAMS

AwsAccountId

DataSetId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId

http DELETE {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteDataSetRefreshProperties

{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties

QUERY PARAMS

AwsAccountId

DataSetId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties

http DELETE {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteDataSource

{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId

QUERY PARAMS

AwsAccountId

DataSourceId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/accounts/:AwsAccountId/data-sources/:DataSourceId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/data-sources/:DataSourceId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/accounts/:AwsAccountId/data-sources/:DataSourceId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/accounts/:AwsAccountId/data-sources/:DataSourceId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId

http DELETE {{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteFolder

{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId

QUERY PARAMS

AwsAccountId

FolderId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/accounts/:AwsAccountId/folders/:FolderId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/folders/:FolderId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/accounts/:AwsAccountId/folders/:FolderId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/accounts/:AwsAccountId/folders/:FolderId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId

http DELETE {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteFolderMembership

{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId

QUERY PARAMS

AwsAccountId

FolderId

MemberId

MemberType

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId

http DELETE {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members/:MemberType/:MemberId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteGroup

{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName

QUERY PARAMS

GroupName

AwsAccountId

Namespace

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName

http DELETE {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteGroupMembership

{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName

QUERY PARAMS

MemberName

GroupName

AwsAccountId

Namespace

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName

http DELETE {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteIAMPolicyAssignment

{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName

QUERY PARAMS

AwsAccountId

AssignmentName

Namespace

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName

http DELETE {{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/namespace/:Namespace/iam-policy-assignments/:AssignmentName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteNamespace

{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace

QUERY PARAMS

AwsAccountId

Namespace

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/accounts/:AwsAccountId/namespaces/:Namespace HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace

http DELETE {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteRefreshSchedule

{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId

QUERY PARAMS

DataSetId

AwsAccountId

ScheduleId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId

http DELETE {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteTemplate

{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId

QUERY PARAMS

AwsAccountId

TemplateId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/accounts/:AwsAccountId/templates/:TemplateId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/templates/:TemplateId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/accounts/:AwsAccountId/templates/:TemplateId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/accounts/:AwsAccountId/templates/:TemplateId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId

http DELETE {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteTemplateAlias

{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName

QUERY PARAMS

AwsAccountId

TemplateId

AliasName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName

http DELETE {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteTheme

{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId

QUERY PARAMS

AwsAccountId

ThemeId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/accounts/:AwsAccountId/themes/:ThemeId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/themes/:ThemeId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/accounts/:AwsAccountId/themes/:ThemeId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/accounts/:AwsAccountId/themes/:ThemeId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId

http DELETE {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteThemeAlias

{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName

QUERY PARAMS

AwsAccountId

ThemeId

AliasName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName

http DELETE {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteUser

{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName

QUERY PARAMS

UserName

AwsAccountId

Namespace

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName

http DELETE {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteUserByPrincipalId

{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId

QUERY PARAMS

PrincipalId

AwsAccountId

Namespace

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId

http DELETE {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/user-principals/:PrincipalId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeAccountCustomization

{{baseUrl}}/accounts/:AwsAccountId/customizations

QUERY PARAMS

AwsAccountId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/customizations");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/customizations")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/customizations"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/customizations"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/customizations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/customizations"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/customizations HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/customizations")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/customizations"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/customizations")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/customizations")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/customizations');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/customizations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/customizations';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/customizations',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/customizations")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/customizations',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/customizations'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/customizations');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/customizations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/customizations';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/customizations"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/customizations" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/customizations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/customizations');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/customizations');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/customizations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/customizations' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/customizations' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/customizations")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/customizations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/customizations"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/customizations")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/customizations') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/customizations";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/customizations

http GET {{baseUrl}}/accounts/:AwsAccountId/customizations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/customizations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/customizations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeAccountSettings

{{baseUrl}}/accounts/:AwsAccountId/settings

QUERY PARAMS

AwsAccountId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/settings");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/settings")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/settings"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/settings"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/settings");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/settings"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/settings HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/settings")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/settings"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/settings")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/settings")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/settings');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/settings'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/settings';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/settings',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/settings")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/settings',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/settings'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/settings');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/settings'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/settings';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/settings"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/settings" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/settings",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/settings');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/settings');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/settings');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/settings' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/settings' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/settings")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/settings"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/settings"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/settings")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/settings') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/settings";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/settings

http GET {{baseUrl}}/accounts/:AwsAccountId/settings

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/settings

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/settings")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeAccountSubscription

{{baseUrl}}/account/:AwsAccountId

QUERY PARAMS

AwsAccountId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/:AwsAccountId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/:AwsAccountId")

require "http/client"

url = "{{baseUrl}}/account/:AwsAccountId"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/:AwsAccountId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/:AwsAccountId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/:AwsAccountId"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/account/:AwsAccountId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/:AwsAccountId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/:AwsAccountId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/:AwsAccountId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/:AwsAccountId")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/:AwsAccountId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/account/:AwsAccountId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/:AwsAccountId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/:AwsAccountId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/:AwsAccountId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/:AwsAccountId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/account/:AwsAccountId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/:AwsAccountId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/account/:AwsAccountId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/:AwsAccountId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/:AwsAccountId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/:AwsAccountId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/:AwsAccountId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/:AwsAccountId');

echo $response->getBody();

setUrl('{{baseUrl}}/account/:AwsAccountId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/:AwsAccountId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/:AwsAccountId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/:AwsAccountId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/:AwsAccountId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/:AwsAccountId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/:AwsAccountId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/:AwsAccountId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/:AwsAccountId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/:AwsAccountId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/:AwsAccountId

http GET {{baseUrl}}/account/:AwsAccountId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/:AwsAccountId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/:AwsAccountId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeAnalysis

{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId

QUERY PARAMS

AwsAccountId

AnalysisId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/analyses/:AnalysisId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/analyses/:AnalysisId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/analyses/:AnalysisId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/analyses/:AnalysisId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId

http GET {{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeAnalysisDefinition

{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition

QUERY PARAMS

AwsAccountId

AnalysisId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/analyses/:AnalysisId/definition HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/analyses/:AnalysisId/definition',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/analyses/:AnalysisId/definition")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/analyses/:AnalysisId/definition') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition

http GET {{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/definition")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeAnalysisPermissions

{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions

QUERY PARAMS

AwsAccountId

AnalysisId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/analyses/:AnalysisId/permissions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/analyses/:AnalysisId/permissions',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/analyses/:AnalysisId/permissions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/analyses/:AnalysisId/permissions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions

http GET {{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeDashboard

{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId

QUERY PARAMS

AwsAccountId

DashboardId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId

http GET {{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeDashboardDefinition

{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition

QUERY PARAMS

AwsAccountId

DashboardId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId/definition HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId/definition',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId/definition")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId/definition') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition

http GET {{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/definition")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeDashboardPermissions

{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions

QUERY PARAMS

AwsAccountId

DashboardId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId/permissions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId/permissions',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId/permissions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId/permissions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions

http GET {{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeDataSet

{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId

QUERY PARAMS

AwsAccountId

DataSetId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId

http GET {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeDataSetPermissions

{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions

QUERY PARAMS

AwsAccountId

DataSetId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/permissions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/permissions',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/permissions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/permissions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions

http GET {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeDataSetRefreshProperties

{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties

QUERY PARAMS

AwsAccountId

DataSetId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties

http GET {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeDataSource

{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId

QUERY PARAMS

AwsAccountId

DataSourceId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/data-sources/:DataSourceId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/data-sources/:DataSourceId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/data-sources/:DataSourceId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/data-sources/:DataSourceId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId

http GET {{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeDataSourcePermissions

{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions

QUERY PARAMS

AwsAccountId

DataSourceId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions

http GET {{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeFolder

{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId

QUERY PARAMS

AwsAccountId

FolderId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/folders/:FolderId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/folders/:FolderId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/folders/:FolderId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/folders/:FolderId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId

http GET {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeFolderPermissions

{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions

QUERY PARAMS

AwsAccountId

FolderId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/folders/:FolderId/permissions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/folders/:FolderId/permissions',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/folders/:FolderId/permissions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/folders/:FolderId/permissions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions

http GET {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeFolderResolvedPermissions

{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions

QUERY PARAMS

AwsAccountId

FolderId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions

http GET {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/resolved-permissions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeGroup

{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName

QUERY PARAMS

GroupName

AwsAccountId

Namespace

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName

http GET {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeGroupMembership

{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName

QUERY PARAMS

MemberName

GroupName

AwsAccountId

Namespace

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName

http GET {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members/:MemberName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeIAMPolicyAssignment

{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName

QUERY PARAMS

AwsAccountId

AssignmentName

Namespace

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName

http GET {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeIngestion

{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId

QUERY PARAMS

AwsAccountId

DataSetId

IngestionId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId

http GET {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions/:IngestionId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeIpRestriction

{{baseUrl}}/accounts/:AwsAccountId/ip-restriction

QUERY PARAMS

AwsAccountId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/ip-restriction");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/ip-restriction")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/ip-restriction"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/ip-restriction"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/ip-restriction");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/ip-restriction"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/ip-restriction HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/ip-restriction")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/ip-restriction"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/ip-restriction")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/ip-restriction")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/ip-restriction');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/ip-restriction'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/ip-restriction';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/ip-restriction',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/ip-restriction")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/ip-restriction',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/ip-restriction'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/ip-restriction');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/ip-restriction'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/ip-restriction';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/ip-restriction"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/ip-restriction" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/ip-restriction",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/ip-restriction');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/ip-restriction');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/ip-restriction');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/ip-restriction' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/ip-restriction' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/ip-restriction")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/ip-restriction"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/ip-restriction"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/ip-restriction")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/ip-restriction') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/ip-restriction";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/ip-restriction

http GET {{baseUrl}}/accounts/:AwsAccountId/ip-restriction

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/ip-restriction

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/ip-restriction")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeNamespace

{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace

QUERY PARAMS

AwsAccountId

Namespace

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/namespaces/:Namespace HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace

http GET {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeRefreshSchedule

{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId

QUERY PARAMS

AwsAccountId

DataSetId

ScheduleId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId

http GET {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules/:ScheduleId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeTemplate

{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId

QUERY PARAMS

AwsAccountId

TemplateId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/templates/:TemplateId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/templates/:TemplateId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/templates/:TemplateId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/templates/:TemplateId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId

http GET {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeTemplateAlias

{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName

QUERY PARAMS

AwsAccountId

TemplateId

AliasName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName

http GET {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeTemplateDefinition

{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition

QUERY PARAMS

AwsAccountId

TemplateId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/templates/:TemplateId/definition HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/templates/:TemplateId/definition',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/templates/:TemplateId/definition")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/templates/:TemplateId/definition') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition

http GET {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/definition")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeTemplatePermissions

{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions

QUERY PARAMS

AwsAccountId

TemplateId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/templates/:TemplateId/permissions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/templates/:TemplateId/permissions',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/templates/:TemplateId/permissions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/templates/:TemplateId/permissions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions

http GET {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeTheme

{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId

QUERY PARAMS

AwsAccountId

ThemeId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/themes/:ThemeId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/themes/:ThemeId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/themes/:ThemeId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/themes/:ThemeId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId

http GET {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeThemeAlias

{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName

QUERY PARAMS

AwsAccountId

ThemeId

AliasName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName

http GET {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeThemePermissions

{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions

QUERY PARAMS

AwsAccountId

ThemeId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/themes/:ThemeId/permissions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/themes/:ThemeId/permissions',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/themes/:ThemeId/permissions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/themes/:ThemeId/permissions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions

http GET {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeUser

{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName

QUERY PARAMS

UserName

AwsAccountId

Namespace

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName

http GET {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GenerateEmbedUrlForAnonymousUser

{{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user

QUERY PARAMS

AwsAccountId

BODY json

{
  "SessionLifetimeInMinutes": 0,
  "Namespace": "",
  "SessionTags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "AuthorizedResourceArns": [],
  "ExperienceConfiguration": {
    "Dashboard": "",
    "DashboardVisual": "",
    "QSearchBar": ""
  },
  "AllowedDomains": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"SessionLifetimeInMinutes\": 0,\n  \"Namespace\": \"\",\n  \"SessionTags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"AuthorizedResourceArns\": [],\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"DashboardVisual\": \"\",\n    \"QSearchBar\": \"\"\n  },\n  \"AllowedDomains\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user" {:content-type :json
                                                                                            :form-params {:SessionLifetimeInMinutes 0
                                                                                                          :Namespace ""
                                                                                                          :SessionTags [{:Key ""
                                                                                                                         :Value ""}]
                                                                                                          :AuthorizedResourceArns []
                                                                                                          :ExperienceConfiguration {:Dashboard ""
                                                                                                                                    :DashboardVisual ""
                                                                                                                                    :QSearchBar ""}
                                                                                                          :AllowedDomains []}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"SessionLifetimeInMinutes\": 0,\n  \"Namespace\": \"\",\n  \"SessionTags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"AuthorizedResourceArns\": [],\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"DashboardVisual\": \"\",\n    \"QSearchBar\": \"\"\n  },\n  \"AllowedDomains\": []\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}}/accounts/:AwsAccountId/embed-url/anonymous-user"),
    Content = new StringContent("{\n  \"SessionLifetimeInMinutes\": 0,\n  \"Namespace\": \"\",\n  \"SessionTags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"AuthorizedResourceArns\": [],\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"DashboardVisual\": \"\",\n    \"QSearchBar\": \"\"\n  },\n  \"AllowedDomains\": []\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}}/accounts/:AwsAccountId/embed-url/anonymous-user");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"SessionLifetimeInMinutes\": 0,\n  \"Namespace\": \"\",\n  \"SessionTags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"AuthorizedResourceArns\": [],\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"DashboardVisual\": \"\",\n    \"QSearchBar\": \"\"\n  },\n  \"AllowedDomains\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user"

	payload := strings.NewReader("{\n  \"SessionLifetimeInMinutes\": 0,\n  \"Namespace\": \"\",\n  \"SessionTags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"AuthorizedResourceArns\": [],\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"DashboardVisual\": \"\",\n    \"QSearchBar\": \"\"\n  },\n  \"AllowedDomains\": []\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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/accounts/:AwsAccountId/embed-url/anonymous-user HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 286

{
  "SessionLifetimeInMinutes": 0,
  "Namespace": "",
  "SessionTags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "AuthorizedResourceArns": [],
  "ExperienceConfiguration": {
    "Dashboard": "",
    "DashboardVisual": "",
    "QSearchBar": ""
  },
  "AllowedDomains": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"SessionLifetimeInMinutes\": 0,\n  \"Namespace\": \"\",\n  \"SessionTags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"AuthorizedResourceArns\": [],\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"DashboardVisual\": \"\",\n    \"QSearchBar\": \"\"\n  },\n  \"AllowedDomains\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"SessionLifetimeInMinutes\": 0,\n  \"Namespace\": \"\",\n  \"SessionTags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"AuthorizedResourceArns\": [],\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"DashboardVisual\": \"\",\n    \"QSearchBar\": \"\"\n  },\n  \"AllowedDomains\": []\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  \"SessionLifetimeInMinutes\": 0,\n  \"Namespace\": \"\",\n  \"SessionTags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"AuthorizedResourceArns\": [],\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"DashboardVisual\": \"\",\n    \"QSearchBar\": \"\"\n  },\n  \"AllowedDomains\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user")
  .header("content-type", "application/json")
  .body("{\n  \"SessionLifetimeInMinutes\": 0,\n  \"Namespace\": \"\",\n  \"SessionTags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"AuthorizedResourceArns\": [],\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"DashboardVisual\": \"\",\n    \"QSearchBar\": \"\"\n  },\n  \"AllowedDomains\": []\n}")
  .asString();

const data = JSON.stringify({
  SessionLifetimeInMinutes: 0,
  Namespace: '',
  SessionTags: [
    {
      Key: '',
      Value: ''
    }
  ],
  AuthorizedResourceArns: [],
  ExperienceConfiguration: {
    Dashboard: '',
    DashboardVisual: '',
    QSearchBar: ''
  },
  AllowedDomains: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user',
  headers: {'content-type': 'application/json'},
  data: {
    SessionLifetimeInMinutes: 0,
    Namespace: '',
    SessionTags: [{Key: '', Value: ''}],
    AuthorizedResourceArns: [],
    ExperienceConfiguration: {Dashboard: '', DashboardVisual: '', QSearchBar: ''},
    AllowedDomains: []
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"SessionLifetimeInMinutes":0,"Namespace":"","SessionTags":[{"Key":"","Value":""}],"AuthorizedResourceArns":[],"ExperienceConfiguration":{"Dashboard":"","DashboardVisual":"","QSearchBar":""},"AllowedDomains":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "SessionLifetimeInMinutes": 0,\n  "Namespace": "",\n  "SessionTags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "AuthorizedResourceArns": [],\n  "ExperienceConfiguration": {\n    "Dashboard": "",\n    "DashboardVisual": "",\n    "QSearchBar": ""\n  },\n  "AllowedDomains": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"SessionLifetimeInMinutes\": 0,\n  \"Namespace\": \"\",\n  \"SessionTags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"AuthorizedResourceArns\": [],\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"DashboardVisual\": \"\",\n    \"QSearchBar\": \"\"\n  },\n  \"AllowedDomains\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user")
  .post(body)
  .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/accounts/:AwsAccountId/embed-url/anonymous-user',
  headers: {
    '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({
  SessionLifetimeInMinutes: 0,
  Namespace: '',
  SessionTags: [{Key: '', Value: ''}],
  AuthorizedResourceArns: [],
  ExperienceConfiguration: {Dashboard: '', DashboardVisual: '', QSearchBar: ''},
  AllowedDomains: []
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user',
  headers: {'content-type': 'application/json'},
  body: {
    SessionLifetimeInMinutes: 0,
    Namespace: '',
    SessionTags: [{Key: '', Value: ''}],
    AuthorizedResourceArns: [],
    ExperienceConfiguration: {Dashboard: '', DashboardVisual: '', QSearchBar: ''},
    AllowedDomains: []
  },
  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}}/accounts/:AwsAccountId/embed-url/anonymous-user');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  SessionLifetimeInMinutes: 0,
  Namespace: '',
  SessionTags: [
    {
      Key: '',
      Value: ''
    }
  ],
  AuthorizedResourceArns: [],
  ExperienceConfiguration: {
    Dashboard: '',
    DashboardVisual: '',
    QSearchBar: ''
  },
  AllowedDomains: []
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user',
  headers: {'content-type': 'application/json'},
  data: {
    SessionLifetimeInMinutes: 0,
    Namespace: '',
    SessionTags: [{Key: '', Value: ''}],
    AuthorizedResourceArns: [],
    ExperienceConfiguration: {Dashboard: '', DashboardVisual: '', QSearchBar: ''},
    AllowedDomains: []
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"SessionLifetimeInMinutes":0,"Namespace":"","SessionTags":[{"Key":"","Value":""}],"AuthorizedResourceArns":[],"ExperienceConfiguration":{"Dashboard":"","DashboardVisual":"","QSearchBar":""},"AllowedDomains":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"SessionLifetimeInMinutes": @0,
                              @"Namespace": @"",
                              @"SessionTags": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"AuthorizedResourceArns": @[  ],
                              @"ExperienceConfiguration": @{ @"Dashboard": @"", @"DashboardVisual": @"", @"QSearchBar": @"" },
                              @"AllowedDomains": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user"]
                                                       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}}/accounts/:AwsAccountId/embed-url/anonymous-user" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"SessionLifetimeInMinutes\": 0,\n  \"Namespace\": \"\",\n  \"SessionTags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"AuthorizedResourceArns\": [],\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"DashboardVisual\": \"\",\n    \"QSearchBar\": \"\"\n  },\n  \"AllowedDomains\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user",
  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([
    'SessionLifetimeInMinutes' => 0,
    'Namespace' => '',
    'SessionTags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'AuthorizedResourceArns' => [
        
    ],
    'ExperienceConfiguration' => [
        'Dashboard' => '',
        'DashboardVisual' => '',
        'QSearchBar' => ''
    ],
    'AllowedDomains' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user', [
  'body' => '{
  "SessionLifetimeInMinutes": 0,
  "Namespace": "",
  "SessionTags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "AuthorizedResourceArns": [],
  "ExperienceConfiguration": {
    "Dashboard": "",
    "DashboardVisual": "",
    "QSearchBar": ""
  },
  "AllowedDomains": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'SessionLifetimeInMinutes' => 0,
  'Namespace' => '',
  'SessionTags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'AuthorizedResourceArns' => [
    
  ],
  'ExperienceConfiguration' => [
    'Dashboard' => '',
    'DashboardVisual' => '',
    'QSearchBar' => ''
  ],
  'AllowedDomains' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'SessionLifetimeInMinutes' => 0,
  'Namespace' => '',
  'SessionTags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'AuthorizedResourceArns' => [
    
  ],
  'ExperienceConfiguration' => [
    'Dashboard' => '',
    'DashboardVisual' => '',
    'QSearchBar' => ''
  ],
  'AllowedDomains' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SessionLifetimeInMinutes": 0,
  "Namespace": "",
  "SessionTags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "AuthorizedResourceArns": [],
  "ExperienceConfiguration": {
    "Dashboard": "",
    "DashboardVisual": "",
    "QSearchBar": ""
  },
  "AllowedDomains": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SessionLifetimeInMinutes": 0,
  "Namespace": "",
  "SessionTags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "AuthorizedResourceArns": [],
  "ExperienceConfiguration": {
    "Dashboard": "",
    "DashboardVisual": "",
    "QSearchBar": ""
  },
  "AllowedDomains": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"SessionLifetimeInMinutes\": 0,\n  \"Namespace\": \"\",\n  \"SessionTags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"AuthorizedResourceArns\": [],\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"DashboardVisual\": \"\",\n    \"QSearchBar\": \"\"\n  },\n  \"AllowedDomains\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/accounts/:AwsAccountId/embed-url/anonymous-user", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user"

payload = {
    "SessionLifetimeInMinutes": 0,
    "Namespace": "",
    "SessionTags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "AuthorizedResourceArns": [],
    "ExperienceConfiguration": {
        "Dashboard": "",
        "DashboardVisual": "",
        "QSearchBar": ""
    },
    "AllowedDomains": []
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user"

payload <- "{\n  \"SessionLifetimeInMinutes\": 0,\n  \"Namespace\": \"\",\n  \"SessionTags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"AuthorizedResourceArns\": [],\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"DashboardVisual\": \"\",\n    \"QSearchBar\": \"\"\n  },\n  \"AllowedDomains\": []\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"SessionLifetimeInMinutes\": 0,\n  \"Namespace\": \"\",\n  \"SessionTags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"AuthorizedResourceArns\": [],\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"DashboardVisual\": \"\",\n    \"QSearchBar\": \"\"\n  },\n  \"AllowedDomains\": []\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/accounts/:AwsAccountId/embed-url/anonymous-user') do |req|
  req.body = "{\n  \"SessionLifetimeInMinutes\": 0,\n  \"Namespace\": \"\",\n  \"SessionTags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"AuthorizedResourceArns\": [],\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"DashboardVisual\": \"\",\n    \"QSearchBar\": \"\"\n  },\n  \"AllowedDomains\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user";

    let payload = json!({
        "SessionLifetimeInMinutes": 0,
        "Namespace": "",
        "SessionTags": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "AuthorizedResourceArns": (),
        "ExperienceConfiguration": json!({
            "Dashboard": "",
            "DashboardVisual": "",
            "QSearchBar": ""
        }),
        "AllowedDomains": ()
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user \
  --header 'content-type: application/json' \
  --data '{
  "SessionLifetimeInMinutes": 0,
  "Namespace": "",
  "SessionTags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "AuthorizedResourceArns": [],
  "ExperienceConfiguration": {
    "Dashboard": "",
    "DashboardVisual": "",
    "QSearchBar": ""
  },
  "AllowedDomains": []
}'

echo '{
  "SessionLifetimeInMinutes": 0,
  "Namespace": "",
  "SessionTags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "AuthorizedResourceArns": [],
  "ExperienceConfiguration": {
    "Dashboard": "",
    "DashboardVisual": "",
    "QSearchBar": ""
  },
  "AllowedDomains": []
}' |  \
  http POST {{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "SessionLifetimeInMinutes": 0,\n  "Namespace": "",\n  "SessionTags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "AuthorizedResourceArns": [],\n  "ExperienceConfiguration": {\n    "Dashboard": "",\n    "DashboardVisual": "",\n    "QSearchBar": ""\n  },\n  "AllowedDomains": []\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "SessionLifetimeInMinutes": 0,
  "Namespace": "",
  "SessionTags": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "AuthorizedResourceArns": [],
  "ExperienceConfiguration": [
    "Dashboard": "",
    "DashboardVisual": "",
    "QSearchBar": ""
  ],
  "AllowedDomains": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/embed-url/anonymous-user")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GenerateEmbedUrlForRegisteredUser

{{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user

QUERY PARAMS

AwsAccountId

BODY json

{
  "SessionLifetimeInMinutes": 0,
  "UserArn": "",
  "ExperienceConfiguration": {
    "Dashboard": "",
    "QuickSightConsole": "",
    "QSearchBar": "",
    "DashboardVisual": ""
  },
  "AllowedDomains": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"SessionLifetimeInMinutes\": 0,\n  \"UserArn\": \"\",\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"QuickSightConsole\": \"\",\n    \"QSearchBar\": \"\",\n    \"DashboardVisual\": \"\"\n  },\n  \"AllowedDomains\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user" {:content-type :json
                                                                                             :form-params {:SessionLifetimeInMinutes 0
                                                                                                           :UserArn ""
                                                                                                           :ExperienceConfiguration {:Dashboard ""
                                                                                                                                     :QuickSightConsole ""
                                                                                                                                     :QSearchBar ""
                                                                                                                                     :DashboardVisual ""}
                                                                                                           :AllowedDomains []}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"SessionLifetimeInMinutes\": 0,\n  \"UserArn\": \"\",\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"QuickSightConsole\": \"\",\n    \"QSearchBar\": \"\",\n    \"DashboardVisual\": \"\"\n  },\n  \"AllowedDomains\": []\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}}/accounts/:AwsAccountId/embed-url/registered-user"),
    Content = new StringContent("{\n  \"SessionLifetimeInMinutes\": 0,\n  \"UserArn\": \"\",\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"QuickSightConsole\": \"\",\n    \"QSearchBar\": \"\",\n    \"DashboardVisual\": \"\"\n  },\n  \"AllowedDomains\": []\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}}/accounts/:AwsAccountId/embed-url/registered-user");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"SessionLifetimeInMinutes\": 0,\n  \"UserArn\": \"\",\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"QuickSightConsole\": \"\",\n    \"QSearchBar\": \"\",\n    \"DashboardVisual\": \"\"\n  },\n  \"AllowedDomains\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user"

	payload := strings.NewReader("{\n  \"SessionLifetimeInMinutes\": 0,\n  \"UserArn\": \"\",\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"QuickSightConsole\": \"\",\n    \"QSearchBar\": \"\",\n    \"DashboardVisual\": \"\"\n  },\n  \"AllowedDomains\": []\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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/accounts/:AwsAccountId/embed-url/registered-user HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 210

{
  "SessionLifetimeInMinutes": 0,
  "UserArn": "",
  "ExperienceConfiguration": {
    "Dashboard": "",
    "QuickSightConsole": "",
    "QSearchBar": "",
    "DashboardVisual": ""
  },
  "AllowedDomains": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"SessionLifetimeInMinutes\": 0,\n  \"UserArn\": \"\",\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"QuickSightConsole\": \"\",\n    \"QSearchBar\": \"\",\n    \"DashboardVisual\": \"\"\n  },\n  \"AllowedDomains\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"SessionLifetimeInMinutes\": 0,\n  \"UserArn\": \"\",\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"QuickSightConsole\": \"\",\n    \"QSearchBar\": \"\",\n    \"DashboardVisual\": \"\"\n  },\n  \"AllowedDomains\": []\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  \"SessionLifetimeInMinutes\": 0,\n  \"UserArn\": \"\",\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"QuickSightConsole\": \"\",\n    \"QSearchBar\": \"\",\n    \"DashboardVisual\": \"\"\n  },\n  \"AllowedDomains\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user")
  .header("content-type", "application/json")
  .body("{\n  \"SessionLifetimeInMinutes\": 0,\n  \"UserArn\": \"\",\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"QuickSightConsole\": \"\",\n    \"QSearchBar\": \"\",\n    \"DashboardVisual\": \"\"\n  },\n  \"AllowedDomains\": []\n}")
  .asString();

const data = JSON.stringify({
  SessionLifetimeInMinutes: 0,
  UserArn: '',
  ExperienceConfiguration: {
    Dashboard: '',
    QuickSightConsole: '',
    QSearchBar: '',
    DashboardVisual: ''
  },
  AllowedDomains: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user',
  headers: {'content-type': 'application/json'},
  data: {
    SessionLifetimeInMinutes: 0,
    UserArn: '',
    ExperienceConfiguration: {Dashboard: '', QuickSightConsole: '', QSearchBar: '', DashboardVisual: ''},
    AllowedDomains: []
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"SessionLifetimeInMinutes":0,"UserArn":"","ExperienceConfiguration":{"Dashboard":"","QuickSightConsole":"","QSearchBar":"","DashboardVisual":""},"AllowedDomains":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "SessionLifetimeInMinutes": 0,\n  "UserArn": "",\n  "ExperienceConfiguration": {\n    "Dashboard": "",\n    "QuickSightConsole": "",\n    "QSearchBar": "",\n    "DashboardVisual": ""\n  },\n  "AllowedDomains": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"SessionLifetimeInMinutes\": 0,\n  \"UserArn\": \"\",\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"QuickSightConsole\": \"\",\n    \"QSearchBar\": \"\",\n    \"DashboardVisual\": \"\"\n  },\n  \"AllowedDomains\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user")
  .post(body)
  .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/accounts/:AwsAccountId/embed-url/registered-user',
  headers: {
    '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({
  SessionLifetimeInMinutes: 0,
  UserArn: '',
  ExperienceConfiguration: {Dashboard: '', QuickSightConsole: '', QSearchBar: '', DashboardVisual: ''},
  AllowedDomains: []
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user',
  headers: {'content-type': 'application/json'},
  body: {
    SessionLifetimeInMinutes: 0,
    UserArn: '',
    ExperienceConfiguration: {Dashboard: '', QuickSightConsole: '', QSearchBar: '', DashboardVisual: ''},
    AllowedDomains: []
  },
  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}}/accounts/:AwsAccountId/embed-url/registered-user');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  SessionLifetimeInMinutes: 0,
  UserArn: '',
  ExperienceConfiguration: {
    Dashboard: '',
    QuickSightConsole: '',
    QSearchBar: '',
    DashboardVisual: ''
  },
  AllowedDomains: []
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user',
  headers: {'content-type': 'application/json'},
  data: {
    SessionLifetimeInMinutes: 0,
    UserArn: '',
    ExperienceConfiguration: {Dashboard: '', QuickSightConsole: '', QSearchBar: '', DashboardVisual: ''},
    AllowedDomains: []
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"SessionLifetimeInMinutes":0,"UserArn":"","ExperienceConfiguration":{"Dashboard":"","QuickSightConsole":"","QSearchBar":"","DashboardVisual":""},"AllowedDomains":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"SessionLifetimeInMinutes": @0,
                              @"UserArn": @"",
                              @"ExperienceConfiguration": @{ @"Dashboard": @"", @"QuickSightConsole": @"", @"QSearchBar": @"", @"DashboardVisual": @"" },
                              @"AllowedDomains": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user"]
                                                       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}}/accounts/:AwsAccountId/embed-url/registered-user" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"SessionLifetimeInMinutes\": 0,\n  \"UserArn\": \"\",\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"QuickSightConsole\": \"\",\n    \"QSearchBar\": \"\",\n    \"DashboardVisual\": \"\"\n  },\n  \"AllowedDomains\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user",
  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([
    'SessionLifetimeInMinutes' => 0,
    'UserArn' => '',
    'ExperienceConfiguration' => [
        'Dashboard' => '',
        'QuickSightConsole' => '',
        'QSearchBar' => '',
        'DashboardVisual' => ''
    ],
    'AllowedDomains' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user', [
  'body' => '{
  "SessionLifetimeInMinutes": 0,
  "UserArn": "",
  "ExperienceConfiguration": {
    "Dashboard": "",
    "QuickSightConsole": "",
    "QSearchBar": "",
    "DashboardVisual": ""
  },
  "AllowedDomains": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'SessionLifetimeInMinutes' => 0,
  'UserArn' => '',
  'ExperienceConfiguration' => [
    'Dashboard' => '',
    'QuickSightConsole' => '',
    'QSearchBar' => '',
    'DashboardVisual' => ''
  ],
  'AllowedDomains' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'SessionLifetimeInMinutes' => 0,
  'UserArn' => '',
  'ExperienceConfiguration' => [
    'Dashboard' => '',
    'QuickSightConsole' => '',
    'QSearchBar' => '',
    'DashboardVisual' => ''
  ],
  'AllowedDomains' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SessionLifetimeInMinutes": 0,
  "UserArn": "",
  "ExperienceConfiguration": {
    "Dashboard": "",
    "QuickSightConsole": "",
    "QSearchBar": "",
    "DashboardVisual": ""
  },
  "AllowedDomains": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SessionLifetimeInMinutes": 0,
  "UserArn": "",
  "ExperienceConfiguration": {
    "Dashboard": "",
    "QuickSightConsole": "",
    "QSearchBar": "",
    "DashboardVisual": ""
  },
  "AllowedDomains": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"SessionLifetimeInMinutes\": 0,\n  \"UserArn\": \"\",\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"QuickSightConsole\": \"\",\n    \"QSearchBar\": \"\",\n    \"DashboardVisual\": \"\"\n  },\n  \"AllowedDomains\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/accounts/:AwsAccountId/embed-url/registered-user", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user"

payload = {
    "SessionLifetimeInMinutes": 0,
    "UserArn": "",
    "ExperienceConfiguration": {
        "Dashboard": "",
        "QuickSightConsole": "",
        "QSearchBar": "",
        "DashboardVisual": ""
    },
    "AllowedDomains": []
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user"

payload <- "{\n  \"SessionLifetimeInMinutes\": 0,\n  \"UserArn\": \"\",\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"QuickSightConsole\": \"\",\n    \"QSearchBar\": \"\",\n    \"DashboardVisual\": \"\"\n  },\n  \"AllowedDomains\": []\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"SessionLifetimeInMinutes\": 0,\n  \"UserArn\": \"\",\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"QuickSightConsole\": \"\",\n    \"QSearchBar\": \"\",\n    \"DashboardVisual\": \"\"\n  },\n  \"AllowedDomains\": []\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/accounts/:AwsAccountId/embed-url/registered-user') do |req|
  req.body = "{\n  \"SessionLifetimeInMinutes\": 0,\n  \"UserArn\": \"\",\n  \"ExperienceConfiguration\": {\n    \"Dashboard\": \"\",\n    \"QuickSightConsole\": \"\",\n    \"QSearchBar\": \"\",\n    \"DashboardVisual\": \"\"\n  },\n  \"AllowedDomains\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user";

    let payload = json!({
        "SessionLifetimeInMinutes": 0,
        "UserArn": "",
        "ExperienceConfiguration": json!({
            "Dashboard": "",
            "QuickSightConsole": "",
            "QSearchBar": "",
            "DashboardVisual": ""
        }),
        "AllowedDomains": ()
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user \
  --header 'content-type: application/json' \
  --data '{
  "SessionLifetimeInMinutes": 0,
  "UserArn": "",
  "ExperienceConfiguration": {
    "Dashboard": "",
    "QuickSightConsole": "",
    "QSearchBar": "",
    "DashboardVisual": ""
  },
  "AllowedDomains": []
}'

echo '{
  "SessionLifetimeInMinutes": 0,
  "UserArn": "",
  "ExperienceConfiguration": {
    "Dashboard": "",
    "QuickSightConsole": "",
    "QSearchBar": "",
    "DashboardVisual": ""
  },
  "AllowedDomains": []
}' |  \
  http POST {{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "SessionLifetimeInMinutes": 0,\n  "UserArn": "",\n  "ExperienceConfiguration": {\n    "Dashboard": "",\n    "QuickSightConsole": "",\n    "QSearchBar": "",\n    "DashboardVisual": ""\n  },\n  "AllowedDomains": []\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "SessionLifetimeInMinutes": 0,
  "UserArn": "",
  "ExperienceConfiguration": [
    "Dashboard": "",
    "QuickSightConsole": "",
    "QSearchBar": "",
    "DashboardVisual": ""
  ],
  "AllowedDomains": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/embed-url/registered-user")! 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()

GET GetDashboardEmbedUrl

{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url#creds-type

QUERY PARAMS

creds-type

AwsAccountId

DashboardId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url?creds-type=#creds-type");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url#creds-type" {:query-params {:creds-type ""}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url?creds-type=#creds-type"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url?creds-type=#creds-type"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url?creds-type=#creds-type");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url?creds-type=#creds-type"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url?creds-type= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url?creds-type=#creds-type")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url?creds-type=#creds-type"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url?creds-type=#creds-type")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url?creds-type=#creds-type")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url?creds-type=#creds-type');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url#creds-type',
  params: {'creds-type': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url?creds-type=#creds-type';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url?creds-type=#creds-type',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url?creds-type=#creds-type")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url?creds-type=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url#creds-type',
  qs: {'creds-type': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url#creds-type');

req.query({
  'creds-type': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url#creds-type',
  params: {'creds-type': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url?creds-type=#creds-type';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url?creds-type=#creds-type"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url?creds-type=#creds-type" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url?creds-type=#creds-type",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url?creds-type=#creds-type');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url#creds-type');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'creds-type' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url#creds-type');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'creds-type' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url?creds-type=#creds-type' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url?creds-type=#creds-type' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url?creds-type=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url#creds-type"

querystring = {"creds-type":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url#creds-type"

queryString <- list(creds-type = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url?creds-type=#creds-type")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url') do |req|
  req.params['creds-type'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url#creds-type";

    let querystring = [
        ("creds-type", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url?creds-type=#creds-type'

http GET '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url?creds-type=#creds-type'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url?creds-type=#creds-type'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/embed-url?creds-type=#creds-type")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET GetSessionEmbedUrl

{{baseUrl}}/accounts/:AwsAccountId/session-embed-url

QUERY PARAMS

AwsAccountId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/session-embed-url");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/session-embed-url")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/session-embed-url"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/session-embed-url"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/session-embed-url");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/session-embed-url"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/session-embed-url HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/session-embed-url")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/session-embed-url"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/session-embed-url")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/session-embed-url")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/session-embed-url');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/session-embed-url'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/session-embed-url';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/session-embed-url',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/session-embed-url")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/session-embed-url',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/session-embed-url'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/session-embed-url');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/session-embed-url'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/session-embed-url';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/session-embed-url"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/session-embed-url" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/session-embed-url",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/session-embed-url');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/session-embed-url');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/session-embed-url');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/session-embed-url' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/session-embed-url' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/session-embed-url")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/session-embed-url"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/session-embed-url"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/session-embed-url")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/session-embed-url') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/session-embed-url";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/session-embed-url

http GET {{baseUrl}}/accounts/:AwsAccountId/session-embed-url

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/session-embed-url

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/session-embed-url")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListAnalyses

{{baseUrl}}/accounts/:AwsAccountId/analyses

QUERY PARAMS

AwsAccountId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/analyses");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/analyses")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/analyses"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/analyses"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/analyses");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/analyses"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/analyses HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/analyses")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/analyses"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/analyses")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/analyses")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/analyses');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/analyses';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/analyses")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/analyses',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/analyses');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/analyses';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/analyses"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/analyses" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/analyses",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/analyses');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/analyses');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/analyses');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/analyses' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/analyses' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/analyses")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/analyses"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/analyses"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/analyses")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/analyses') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/analyses";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/analyses

http GET {{baseUrl}}/accounts/:AwsAccountId/analyses

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/analyses

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/analyses")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListDashboardVersions

{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions

QUERY PARAMS

AwsAccountId

DashboardId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId/versions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId/versions',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId/versions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId/versions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions

http GET {{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListDashboards

{{baseUrl}}/accounts/:AwsAccountId/dashboards

QUERY PARAMS

AwsAccountId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/dashboards");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/dashboards")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/dashboards"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/dashboards");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/dashboards"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/dashboards HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/dashboards")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/dashboards"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/dashboards")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/dashboards")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/dashboards');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/dashboards';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/dashboards")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/dashboards',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/dashboards');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/dashboards';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/dashboards"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/dashboards" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/dashboards",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/dashboards');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/dashboards');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/dashboards');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/dashboards' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/dashboards' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/dashboards")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/dashboards"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/dashboards")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/dashboards') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/dashboards

http GET {{baseUrl}}/accounts/:AwsAccountId/dashboards

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/dashboards

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/dashboards")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListDataSets

{{baseUrl}}/accounts/:AwsAccountId/data-sets

QUERY PARAMS

AwsAccountId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/data-sets");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/data-sets")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/data-sets"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/data-sets");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/data-sets"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/data-sets HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/data-sets")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/data-sets"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/data-sets")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sets');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/data-sets',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sets');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/data-sets"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/data-sets" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/data-sets",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sets');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/data-sets")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/data-sets"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/data-sets")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/data-sets') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/data-sets

http GET {{baseUrl}}/accounts/:AwsAccountId/data-sets

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/data-sets

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/data-sets")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListDataSources

{{baseUrl}}/accounts/:AwsAccountId/data-sources

QUERY PARAMS

AwsAccountId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/data-sources");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/data-sources")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sources"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/data-sources"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/data-sources");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/data-sources"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/data-sources HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/data-sources")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/data-sources"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sources")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/data-sources")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sources');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sources'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sources';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sources',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sources")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/data-sources',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sources'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sources');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sources'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sources';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/data-sources"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/data-sources" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/data-sources",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sources');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sources');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sources');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sources' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sources' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/data-sources")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sources"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/data-sources"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/data-sources")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/data-sources') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/data-sources";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/data-sources

http GET {{baseUrl}}/accounts/:AwsAccountId/data-sources

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/data-sources

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/data-sources")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListFolderMembers

{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members

QUERY PARAMS

AwsAccountId

FolderId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/folders/:FolderId/members HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/folders/:FolderId/members',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/folders/:FolderId/members")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/folders/:FolderId/members') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members

http GET {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/members")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListFolders

{{baseUrl}}/accounts/:AwsAccountId/folders

QUERY PARAMS

AwsAccountId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/folders");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/folders")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/folders"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/folders"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/folders");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/folders"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/folders HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/folders")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/folders"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/folders")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/folders")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/folders');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/folders';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/folders")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/folders',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/folders');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/folders';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/folders"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/folders" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/folders",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/folders');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/folders');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/folders');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/folders' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/folders' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/folders")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/folders"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/folders"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/folders")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/folders') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/folders";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/folders

http GET {{baseUrl}}/accounts/:AwsAccountId/folders

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/folders

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/folders")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListGroupMemberships

{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members

QUERY PARAMS

GroupName

AwsAccountId

Namespace

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members

http GET {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName/members")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListGroups

{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups

QUERY PARAMS

AwsAccountId

Namespace

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups

http GET {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListIAMPolicyAssignments

{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments

QUERY PARAMS

AwsAccountId

Namespace

BODY json

{
  "AssignmentStatus": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"AssignmentStatus\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments" {:content-type :json
                                                                                                               :form-params {:AssignmentStatus ""}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"AssignmentStatus\": \"\"\n}"

response = HTTP::Client.get url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments"),
    Content = new StringContent("{\n  \"AssignmentStatus\": \"\"\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}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments");
var request = new RestRequest("", Method.Get);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AssignmentStatus\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments"

	payload := strings.NewReader("{\n  \"AssignmentStatus\": \"\"\n}")

	req, _ := http.NewRequest("GET", url, payload)

	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))

}

GET /baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 28

{
  "AssignmentStatus": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AssignmentStatus\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments"))
    .header("content-type", "application/json")
    .method("GET", HttpRequest.BodyPublishers.ofString("{\n  \"AssignmentStatus\": \"\"\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  \"AssignmentStatus\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments")
  .get()
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments")
  .header("content-type", "application/json")
  .body("{\n  \"AssignmentStatus\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AssignmentStatus: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments',
  headers: {'content-type': 'application/json'},
  data: {AssignmentStatus: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments';
const options = {
  method: 'GET',
  headers: {'content-type': 'application/json'},
  body: '{"AssignmentStatus":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments',
  method: 'GET',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AssignmentStatus": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AssignmentStatus\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments")
  .get()
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments',
  headers: {
    '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({AssignmentStatus: ''}));
req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments',
  headers: {'content-type': 'application/json'},
  body: {AssignmentStatus: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AssignmentStatus: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments',
  headers: {'content-type': 'application/json'},
  data: {AssignmentStatus: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments';
const options = {
  method: 'GET',
  headers: {'content-type': 'application/json'},
  body: '{"AssignmentStatus":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AssignmentStatus": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[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}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"AssignmentStatus\": \"\"\n}" in

Client.call ~headers ~body `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_POSTFIELDS => json_encode([
    'AssignmentStatus' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments', [
  'body' => '{
  "AssignmentStatus": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AssignmentStatus' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AssignmentStatus' => ''
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments');
$request->setRequestMethod('GET');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments' -Method GET -Headers $headers -ContentType 'application/json' -Body '{
  "AssignmentStatus": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments' -Method GET -Headers $headers -ContentType 'application/json' -Body '{
  "AssignmentStatus": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AssignmentStatus\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments"

payload = { "AssignmentStatus": "" }
headers = {"content-type": "application/json"}

response = requests.get(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments"

payload <- "{\n  \"AssignmentStatus\": \"\"\n}"

encode <- "json"

response <- VERB("GET", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"AssignmentStatus\": \"\"\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.get('/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments') do |req|
  req.body = "{\n  \"AssignmentStatus\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments";

    let payload = json!({"AssignmentStatus": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments \
  --header 'content-type: application/json' \
  --data '{
  "AssignmentStatus": ""
}'

echo '{
  "AssignmentStatus": ""
}' |  \
  http GET {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments \
  content-type:application/json

wget --quiet \
  --method GET \
  --header 'content-type: application/json' \
  --body-data '{\n  "AssignmentStatus": ""\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["AssignmentStatus": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
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()

GET ListIAMPolicyAssignmentsForUser

{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments

QUERY PARAMS

AwsAccountId

UserName

Namespace

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments

http GET {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/iam-policy-assignments")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListIngestions

{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions

QUERY PARAMS

DataSetId

AwsAccountId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions

http GET {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/ingestions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListNamespaces

{{baseUrl}}/accounts/:AwsAccountId/namespaces

QUERY PARAMS

AwsAccountId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/namespaces");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/namespaces")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/namespaces"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/namespaces");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/namespaces"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/namespaces HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/namespaces")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/namespaces"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/namespaces")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/namespaces',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/namespaces"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/namespaces" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/namespaces",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/namespaces")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/namespaces"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/namespaces")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/namespaces') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/namespaces

http GET {{baseUrl}}/accounts/:AwsAccountId/namespaces

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/namespaces

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/namespaces")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListRefreshSchedules

{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules

QUERY PARAMS

AwsAccountId

DataSetId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules

http GET {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListTagsForResource

{{baseUrl}}/resources/:ResourceArn/tags

QUERY PARAMS

ResourceArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resources/:ResourceArn/tags");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/resources/:ResourceArn/tags")

require "http/client"

url = "{{baseUrl}}/resources/:ResourceArn/tags"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/resources/:ResourceArn/tags"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/resources/:ResourceArn/tags");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resources/:ResourceArn/tags"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/resources/:ResourceArn/tags HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/resources/:ResourceArn/tags")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resources/:ResourceArn/tags"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/resources/:ResourceArn/tags")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/resources/:ResourceArn/tags")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/resources/:ResourceArn/tags');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/resources/:ResourceArn/tags'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resources/:ResourceArn/tags';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resources/:ResourceArn/tags',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/resources/:ResourceArn/tags")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resources/:ResourceArn/tags',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/resources/:ResourceArn/tags'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/resources/: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: 'GET', url: '{{baseUrl}}/resources/: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}}/resources/:ResourceArn/tags';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resources/:ResourceArn/tags"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resources/:ResourceArn/tags" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resources/:ResourceArn/tags",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/resources/:ResourceArn/tags');

echo $response->getBody();

setUrl('{{baseUrl}}/resources/:ResourceArn/tags');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/resources/:ResourceArn/tags');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/resources/:ResourceArn/tags' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/resources/:ResourceArn/tags' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/resources/:ResourceArn/tags")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resources/:ResourceArn/tags"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resources/:ResourceArn/tags"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resources/:ResourceArn/tags")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/resources/:ResourceArn/tags') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resources/:ResourceArn/tags";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/resources/:ResourceArn/tags

http GET {{baseUrl}}/resources/:ResourceArn/tags

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/resources/:ResourceArn/tags

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resources/:ResourceArn/tags")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListTemplateAliases

{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases

QUERY PARAMS

AwsAccountId

TemplateId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/templates/:TemplateId/aliases HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/templates/:TemplateId/aliases',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/templates/:TemplateId/aliases")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/templates/:TemplateId/aliases') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases

http GET {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListTemplateVersions

{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions

QUERY PARAMS

AwsAccountId

TemplateId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/templates/:TemplateId/versions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/templates/:TemplateId/versions',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/templates/:TemplateId/versions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/templates/:TemplateId/versions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions

http GET {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/versions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListTemplates

{{baseUrl}}/accounts/:AwsAccountId/templates

QUERY PARAMS

AwsAccountId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/templates");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/templates")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/templates"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/templates"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/templates");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/templates"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/templates HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/templates")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/templates"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/templates")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/templates")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/templates');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/templates';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/templates")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/templates',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/templates');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/templates';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/templates"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/templates" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/templates",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/templates');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/templates');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/templates');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/templates' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/templates' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/templates")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/templates"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/templates"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/templates")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/templates') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/templates";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/templates

http GET {{baseUrl}}/accounts/:AwsAccountId/templates

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/templates

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/templates")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListThemeAliases

{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases

QUERY PARAMS

AwsAccountId

ThemeId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/themes/:ThemeId/aliases HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/themes/:ThemeId/aliases',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/themes/:ThemeId/aliases")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/themes/:ThemeId/aliases') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases

http GET {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListThemeVersions

{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions

QUERY PARAMS

AwsAccountId

ThemeId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/themes/:ThemeId/versions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/themes/:ThemeId/versions',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/themes/:ThemeId/versions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/themes/:ThemeId/versions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions

http GET {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/versions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListThemes

{{baseUrl}}/accounts/:AwsAccountId/themes

QUERY PARAMS

AwsAccountId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/themes");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/themes")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/themes"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/themes"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/themes");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/themes"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/themes HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/themes")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/themes"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/themes")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/themes")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/themes');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/themes';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/themes")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/themes',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/themes');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/themes';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/themes"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/themes" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/themes",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/themes');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/themes');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/themes');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/themes' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/themes' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/themes")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/themes"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/themes"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/themes")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/themes') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/themes";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/themes

http GET {{baseUrl}}/accounts/:AwsAccountId/themes

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/themes

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/themes")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListUserGroups

{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups

QUERY PARAMS

UserName

AwsAccountId

Namespace

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups

http GET {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName/groups")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListUsers

{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users

QUERY PARAMS

AwsAccountId

Namespace

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/users HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/users',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/users")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/users') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users

http GET {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT PutDataSetRefreshProperties

{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties

QUERY PARAMS

AwsAccountId

DataSetId

BODY json

{
  "DataSetRefreshProperties": {
    "RefreshConfiguration": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"DataSetRefreshProperties\": {\n    \"RefreshConfiguration\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties" {:content-type :json
                                                                                                          :form-params {:DataSetRefreshProperties {:RefreshConfiguration ""}}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"DataSetRefreshProperties\": {\n    \"RefreshConfiguration\": \"\"\n  }\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties"),
    Content = new StringContent("{\n  \"DataSetRefreshProperties\": {\n    \"RefreshConfiguration\": \"\"\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}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DataSetRefreshProperties\": {\n    \"RefreshConfiguration\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties"

	payload := strings.NewReader("{\n  \"DataSetRefreshProperties\": {\n    \"RefreshConfiguration\": \"\"\n  }\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	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))

}

PUT /baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 70

{
  "DataSetRefreshProperties": {
    "RefreshConfiguration": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DataSetRefreshProperties\": {\n    \"RefreshConfiguration\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"DataSetRefreshProperties\": {\n    \"RefreshConfiguration\": \"\"\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  \"DataSetRefreshProperties\": {\n    \"RefreshConfiguration\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties")
  .header("content-type", "application/json")
  .body("{\n  \"DataSetRefreshProperties\": {\n    \"RefreshConfiguration\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  DataSetRefreshProperties: {
    RefreshConfiguration: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties',
  headers: {'content-type': 'application/json'},
  data: {DataSetRefreshProperties: {RefreshConfiguration: ''}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"DataSetRefreshProperties":{"RefreshConfiguration":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DataSetRefreshProperties": {\n    "RefreshConfiguration": ""\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  \"DataSetRefreshProperties\": {\n    \"RefreshConfiguration\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties',
  headers: {
    '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({DataSetRefreshProperties: {RefreshConfiguration: ''}}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties',
  headers: {'content-type': 'application/json'},
  body: {DataSetRefreshProperties: {RefreshConfiguration: ''}},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  DataSetRefreshProperties: {
    RefreshConfiguration: ''
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties',
  headers: {'content-type': 'application/json'},
  data: {DataSetRefreshProperties: {RefreshConfiguration: ''}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"DataSetRefreshProperties":{"RefreshConfiguration":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"DataSetRefreshProperties": @{ @"RefreshConfiguration": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"DataSetRefreshProperties\": {\n    \"RefreshConfiguration\": \"\"\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'DataSetRefreshProperties' => [
        'RefreshConfiguration' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties', [
  'body' => '{
  "DataSetRefreshProperties": {
    "RefreshConfiguration": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DataSetRefreshProperties' => [
    'RefreshConfiguration' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'DataSetRefreshProperties' => [
    'RefreshConfiguration' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "DataSetRefreshProperties": {
    "RefreshConfiguration": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "DataSetRefreshProperties": {
    "RefreshConfiguration": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"DataSetRefreshProperties\": {\n    \"RefreshConfiguration\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties"

payload = { "DataSetRefreshProperties": { "RefreshConfiguration": "" } }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties"

payload <- "{\n  \"DataSetRefreshProperties\": {\n    \"RefreshConfiguration\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"DataSetRefreshProperties\": {\n    \"RefreshConfiguration\": \"\"\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.put('/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties') do |req|
  req.body = "{\n  \"DataSetRefreshProperties\": {\n    \"RefreshConfiguration\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties";

    let payload = json!({"DataSetRefreshProperties": json!({"RefreshConfiguration": ""})});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties \
  --header 'content-type: application/json' \
  --data '{
  "DataSetRefreshProperties": {
    "RefreshConfiguration": ""
  }
}'

echo '{
  "DataSetRefreshProperties": {
    "RefreshConfiguration": ""
  }
}' |  \
  http PUT {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "DataSetRefreshProperties": {\n    "RefreshConfiguration": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["DataSetRefreshProperties": ["RefreshConfiguration": ""]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-properties")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST RegisterUser

{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users

QUERY PARAMS

AwsAccountId

Namespace

BODY json

{
  "IdentityType": "",
  "Email": "",
  "UserRole": "",
  "IamArn": "",
  "SessionName": "",
  "UserName": "",
  "CustomPermissionsName": "",
  "ExternalLoginFederationProviderType": "",
  "CustomFederationProviderUrl": "",
  "ExternalLoginId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"IdentityType\": \"\",\n  \"Email\": \"\",\n  \"UserRole\": \"\",\n  \"IamArn\": \"\",\n  \"SessionName\": \"\",\n  \"UserName\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users" {:content-type :json
                                                                                               :form-params {:IdentityType ""
                                                                                                             :Email ""
                                                                                                             :UserRole ""
                                                                                                             :IamArn ""
                                                                                                             :SessionName ""
                                                                                                             :UserName ""
                                                                                                             :CustomPermissionsName ""
                                                                                                             :ExternalLoginFederationProviderType ""
                                                                                                             :CustomFederationProviderUrl ""
                                                                                                             :ExternalLoginId ""}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"IdentityType\": \"\",\n  \"Email\": \"\",\n  \"UserRole\": \"\",\n  \"IamArn\": \"\",\n  \"SessionName\": \"\",\n  \"UserName\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\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}}/accounts/:AwsAccountId/namespaces/:Namespace/users"),
    Content = new StringContent("{\n  \"IdentityType\": \"\",\n  \"Email\": \"\",\n  \"UserRole\": \"\",\n  \"IamArn\": \"\",\n  \"SessionName\": \"\",\n  \"UserName\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\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}}/accounts/:AwsAccountId/namespaces/:Namespace/users");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"IdentityType\": \"\",\n  \"Email\": \"\",\n  \"UserRole\": \"\",\n  \"IamArn\": \"\",\n  \"SessionName\": \"\",\n  \"UserName\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users"

	payload := strings.NewReader("{\n  \"IdentityType\": \"\",\n  \"Email\": \"\",\n  \"UserRole\": \"\",\n  \"IamArn\": \"\",\n  \"SessionName\": \"\",\n  \"UserName\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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/accounts/:AwsAccountId/namespaces/:Namespace/users HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 250

{
  "IdentityType": "",
  "Email": "",
  "UserRole": "",
  "IamArn": "",
  "SessionName": "",
  "UserName": "",
  "CustomPermissionsName": "",
  "ExternalLoginFederationProviderType": "",
  "CustomFederationProviderUrl": "",
  "ExternalLoginId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"IdentityType\": \"\",\n  \"Email\": \"\",\n  \"UserRole\": \"\",\n  \"IamArn\": \"\",\n  \"SessionName\": \"\",\n  \"UserName\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"IdentityType\": \"\",\n  \"Email\": \"\",\n  \"UserRole\": \"\",\n  \"IamArn\": \"\",\n  \"SessionName\": \"\",\n  \"UserName\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\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  \"IdentityType\": \"\",\n  \"Email\": \"\",\n  \"UserRole\": \"\",\n  \"IamArn\": \"\",\n  \"SessionName\": \"\",\n  \"UserName\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users")
  .header("content-type", "application/json")
  .body("{\n  \"IdentityType\": \"\",\n  \"Email\": \"\",\n  \"UserRole\": \"\",\n  \"IamArn\": \"\",\n  \"SessionName\": \"\",\n  \"UserName\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  IdentityType: '',
  Email: '',
  UserRole: '',
  IamArn: '',
  SessionName: '',
  UserName: '',
  CustomPermissionsName: '',
  ExternalLoginFederationProviderType: '',
  CustomFederationProviderUrl: '',
  ExternalLoginId: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users',
  headers: {'content-type': 'application/json'},
  data: {
    IdentityType: '',
    Email: '',
    UserRole: '',
    IamArn: '',
    SessionName: '',
    UserName: '',
    CustomPermissionsName: '',
    ExternalLoginFederationProviderType: '',
    CustomFederationProviderUrl: '',
    ExternalLoginId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"IdentityType":"","Email":"","UserRole":"","IamArn":"","SessionName":"","UserName":"","CustomPermissionsName":"","ExternalLoginFederationProviderType":"","CustomFederationProviderUrl":"","ExternalLoginId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "IdentityType": "",\n  "Email": "",\n  "UserRole": "",\n  "IamArn": "",\n  "SessionName": "",\n  "UserName": "",\n  "CustomPermissionsName": "",\n  "ExternalLoginFederationProviderType": "",\n  "CustomFederationProviderUrl": "",\n  "ExternalLoginId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"IdentityType\": \"\",\n  \"Email\": \"\",\n  \"UserRole\": \"\",\n  \"IamArn\": \"\",\n  \"SessionName\": \"\",\n  \"UserName\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users")
  .post(body)
  .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/accounts/:AwsAccountId/namespaces/:Namespace/users',
  headers: {
    '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({
  IdentityType: '',
  Email: '',
  UserRole: '',
  IamArn: '',
  SessionName: '',
  UserName: '',
  CustomPermissionsName: '',
  ExternalLoginFederationProviderType: '',
  CustomFederationProviderUrl: '',
  ExternalLoginId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users',
  headers: {'content-type': 'application/json'},
  body: {
    IdentityType: '',
    Email: '',
    UserRole: '',
    IamArn: '',
    SessionName: '',
    UserName: '',
    CustomPermissionsName: '',
    ExternalLoginFederationProviderType: '',
    CustomFederationProviderUrl: '',
    ExternalLoginId: ''
  },
  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}}/accounts/:AwsAccountId/namespaces/:Namespace/users');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  IdentityType: '',
  Email: '',
  UserRole: '',
  IamArn: '',
  SessionName: '',
  UserName: '',
  CustomPermissionsName: '',
  ExternalLoginFederationProviderType: '',
  CustomFederationProviderUrl: '',
  ExternalLoginId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users',
  headers: {'content-type': 'application/json'},
  data: {
    IdentityType: '',
    Email: '',
    UserRole: '',
    IamArn: '',
    SessionName: '',
    UserName: '',
    CustomPermissionsName: '',
    ExternalLoginFederationProviderType: '',
    CustomFederationProviderUrl: '',
    ExternalLoginId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"IdentityType":"","Email":"","UserRole":"","IamArn":"","SessionName":"","UserName":"","CustomPermissionsName":"","ExternalLoginFederationProviderType":"","CustomFederationProviderUrl":"","ExternalLoginId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"IdentityType": @"",
                              @"Email": @"",
                              @"UserRole": @"",
                              @"IamArn": @"",
                              @"SessionName": @"",
                              @"UserName": @"",
                              @"CustomPermissionsName": @"",
                              @"ExternalLoginFederationProviderType": @"",
                              @"CustomFederationProviderUrl": @"",
                              @"ExternalLoginId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users"]
                                                       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}}/accounts/:AwsAccountId/namespaces/:Namespace/users" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"IdentityType\": \"\",\n  \"Email\": \"\",\n  \"UserRole\": \"\",\n  \"IamArn\": \"\",\n  \"SessionName\": \"\",\n  \"UserName\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users",
  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([
    'IdentityType' => '',
    'Email' => '',
    'UserRole' => '',
    'IamArn' => '',
    'SessionName' => '',
    'UserName' => '',
    'CustomPermissionsName' => '',
    'ExternalLoginFederationProviderType' => '',
    'CustomFederationProviderUrl' => '',
    'ExternalLoginId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users', [
  'body' => '{
  "IdentityType": "",
  "Email": "",
  "UserRole": "",
  "IamArn": "",
  "SessionName": "",
  "UserName": "",
  "CustomPermissionsName": "",
  "ExternalLoginFederationProviderType": "",
  "CustomFederationProviderUrl": "",
  "ExternalLoginId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'IdentityType' => '',
  'Email' => '',
  'UserRole' => '',
  'IamArn' => '',
  'SessionName' => '',
  'UserName' => '',
  'CustomPermissionsName' => '',
  'ExternalLoginFederationProviderType' => '',
  'CustomFederationProviderUrl' => '',
  'ExternalLoginId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'IdentityType' => '',
  'Email' => '',
  'UserRole' => '',
  'IamArn' => '',
  'SessionName' => '',
  'UserName' => '',
  'CustomPermissionsName' => '',
  'ExternalLoginFederationProviderType' => '',
  'CustomFederationProviderUrl' => '',
  'ExternalLoginId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "IdentityType": "",
  "Email": "",
  "UserRole": "",
  "IamArn": "",
  "SessionName": "",
  "UserName": "",
  "CustomPermissionsName": "",
  "ExternalLoginFederationProviderType": "",
  "CustomFederationProviderUrl": "",
  "ExternalLoginId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "IdentityType": "",
  "Email": "",
  "UserRole": "",
  "IamArn": "",
  "SessionName": "",
  "UserName": "",
  "CustomPermissionsName": "",
  "ExternalLoginFederationProviderType": "",
  "CustomFederationProviderUrl": "",
  "ExternalLoginId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"IdentityType\": \"\",\n  \"Email\": \"\",\n  \"UserRole\": \"\",\n  \"IamArn\": \"\",\n  \"SessionName\": \"\",\n  \"UserName\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/users", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users"

payload = {
    "IdentityType": "",
    "Email": "",
    "UserRole": "",
    "IamArn": "",
    "SessionName": "",
    "UserName": "",
    "CustomPermissionsName": "",
    "ExternalLoginFederationProviderType": "",
    "CustomFederationProviderUrl": "",
    "ExternalLoginId": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users"

payload <- "{\n  \"IdentityType\": \"\",\n  \"Email\": \"\",\n  \"UserRole\": \"\",\n  \"IamArn\": \"\",\n  \"SessionName\": \"\",\n  \"UserName\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"IdentityType\": \"\",\n  \"Email\": \"\",\n  \"UserRole\": \"\",\n  \"IamArn\": \"\",\n  \"SessionName\": \"\",\n  \"UserName\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\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/accounts/:AwsAccountId/namespaces/:Namespace/users') do |req|
  req.body = "{\n  \"IdentityType\": \"\",\n  \"Email\": \"\",\n  \"UserRole\": \"\",\n  \"IamArn\": \"\",\n  \"SessionName\": \"\",\n  \"UserName\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users";

    let payload = json!({
        "IdentityType": "",
        "Email": "",
        "UserRole": "",
        "IamArn": "",
        "SessionName": "",
        "UserName": "",
        "CustomPermissionsName": "",
        "ExternalLoginFederationProviderType": "",
        "CustomFederationProviderUrl": "",
        "ExternalLoginId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users \
  --header 'content-type: application/json' \
  --data '{
  "IdentityType": "",
  "Email": "",
  "UserRole": "",
  "IamArn": "",
  "SessionName": "",
  "UserName": "",
  "CustomPermissionsName": "",
  "ExternalLoginFederationProviderType": "",
  "CustomFederationProviderUrl": "",
  "ExternalLoginId": ""
}'

echo '{
  "IdentityType": "",
  "Email": "",
  "UserRole": "",
  "IamArn": "",
  "SessionName": "",
  "UserName": "",
  "CustomPermissionsName": "",
  "ExternalLoginFederationProviderType": "",
  "CustomFederationProviderUrl": "",
  "ExternalLoginId": ""
}' |  \
  http POST {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "IdentityType": "",\n  "Email": "",\n  "UserRole": "",\n  "IamArn": "",\n  "SessionName": "",\n  "UserName": "",\n  "CustomPermissionsName": "",\n  "ExternalLoginFederationProviderType": "",\n  "CustomFederationProviderUrl": "",\n  "ExternalLoginId": ""\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "IdentityType": "",
  "Email": "",
  "UserRole": "",
  "IamArn": "",
  "SessionName": "",
  "UserName": "",
  "CustomPermissionsName": "",
  "ExternalLoginFederationProviderType": "",
  "CustomFederationProviderUrl": "",
  "ExternalLoginId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST RestoreAnalysis

{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId

QUERY PARAMS

AwsAccountId

AnalysisId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/accounts/:AwsAccountId/restore/analyses/:AnalysisId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/restore/analyses/:AnalysisId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/accounts/:AwsAccountId/restore/analyses/:AnalysisId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/accounts/:AwsAccountId/restore/analyses/:AnalysisId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId

http POST {{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/restore/analyses/:AnalysisId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST SearchAnalyses

{{baseUrl}}/accounts/:AwsAccountId/search/analyses

QUERY PARAMS

AwsAccountId

BODY json

{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/search/analyses");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/accounts/:AwsAccountId/search/analyses" {:content-type :json
                                                                                   :form-params {:Filters [{:Operator ""
                                                                                                            :Name ""
                                                                                                            :Value ""}]
                                                                                                 :NextToken ""
                                                                                                 :MaxResults 0}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/search/analyses"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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}}/accounts/:AwsAccountId/search/analyses"),
    Content = new StringContent("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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}}/accounts/:AwsAccountId/search/analyses");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/search/analyses"

	payload := strings.NewReader("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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/accounts/:AwsAccountId/search/analyses HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 130

{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:AwsAccountId/search/analyses")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/search/analyses"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/search/analyses")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:AwsAccountId/search/analyses")
  .header("content-type", "application/json")
  .body("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")
  .asString();

const data = JSON.stringify({
  Filters: [
    {
      Operator: '',
      Name: '',
      Value: ''
    }
  ],
  NextToken: '',
  MaxResults: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/accounts/:AwsAccountId/search/analyses');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/search/analyses',
  headers: {'content-type': 'application/json'},
  data: {Filters: [{Operator: '', Name: '', Value: ''}], NextToken: '', MaxResults: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/search/analyses';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Filters":[{"Operator":"","Name":"","Value":""}],"NextToken":"","MaxResults":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/search/analyses',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Filters": [\n    {\n      "Operator": "",\n      "Name": "",\n      "Value": ""\n    }\n  ],\n  "NextToken": "",\n  "MaxResults": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/search/analyses")
  .post(body)
  .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/accounts/:AwsAccountId/search/analyses',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Filters: [{Operator: '', Name: '', Value: ''}], NextToken: '', MaxResults: 0}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/search/analyses',
  headers: {'content-type': 'application/json'},
  body: {Filters: [{Operator: '', Name: '', Value: ''}], NextToken: '', MaxResults: 0},
  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}}/accounts/:AwsAccountId/search/analyses');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Filters: [
    {
      Operator: '',
      Name: '',
      Value: ''
    }
  ],
  NextToken: '',
  MaxResults: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/search/analyses',
  headers: {'content-type': 'application/json'},
  data: {Filters: [{Operator: '', Name: '', Value: ''}], NextToken: '', MaxResults: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/search/analyses';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Filters":[{"Operator":"","Name":"","Value":""}],"NextToken":"","MaxResults":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Filters": @[ @{ @"Operator": @"", @"Name": @"", @"Value": @"" } ],
                              @"NextToken": @"",
                              @"MaxResults": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/search/analyses"]
                                                       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}}/accounts/:AwsAccountId/search/analyses" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/search/analyses",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Filters' => [
        [
                'Operator' => '',
                'Name' => '',
                'Value' => ''
        ]
    ],
    'NextToken' => '',
    'MaxResults' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/accounts/:AwsAccountId/search/analyses', [
  'body' => '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/search/analyses');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => [
    [
        'Operator' => '',
        'Name' => '',
        'Value' => ''
    ]
  ],
  'NextToken' => '',
  'MaxResults' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Filters' => [
    [
        'Operator' => '',
        'Name' => '',
        'Value' => ''
    ]
  ],
  'NextToken' => '',
  'MaxResults' => 0
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/search/analyses');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/search/analyses' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/search/analyses' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/accounts/:AwsAccountId/search/analyses", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/search/analyses"

payload = {
    "Filters": [
        {
            "Operator": "",
            "Name": "",
            "Value": ""
        }
    ],
    "NextToken": "",
    "MaxResults": 0
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/search/analyses"

payload <- "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/search/analyses")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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/accounts/:AwsAccountId/search/analyses') do |req|
  req.body = "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/search/analyses";

    let payload = json!({
        "Filters": (
            json!({
                "Operator": "",
                "Name": "",
                "Value": ""
            })
        ),
        "NextToken": "",
        "MaxResults": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/accounts/:AwsAccountId/search/analyses \
  --header 'content-type: application/json' \
  --data '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}'

echo '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}' |  \
  http POST {{baseUrl}}/accounts/:AwsAccountId/search/analyses \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Filters": [\n    {\n      "Operator": "",\n      "Name": "",\n      "Value": ""\n    }\n  ],\n  "NextToken": "",\n  "MaxResults": 0\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/search/analyses

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Filters": [
    [
      "Operator": "",
      "Name": "",
      "Value": ""
    ]
  ],
  "NextToken": "",
  "MaxResults": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/search/analyses")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST SearchDashboards

{{baseUrl}}/accounts/:AwsAccountId/search/dashboards

QUERY PARAMS

AwsAccountId

BODY json

{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/search/dashboards");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/accounts/:AwsAccountId/search/dashboards" {:content-type :json
                                                                                     :form-params {:Filters [{:Operator ""
                                                                                                              :Name ""
                                                                                                              :Value ""}]
                                                                                                   :NextToken ""
                                                                                                   :MaxResults 0}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/search/dashboards"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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}}/accounts/:AwsAccountId/search/dashboards"),
    Content = new StringContent("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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}}/accounts/:AwsAccountId/search/dashboards");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/search/dashboards"

	payload := strings.NewReader("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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/accounts/:AwsAccountId/search/dashboards HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 130

{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:AwsAccountId/search/dashboards")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/search/dashboards"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/search/dashboards")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:AwsAccountId/search/dashboards")
  .header("content-type", "application/json")
  .body("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")
  .asString();

const data = JSON.stringify({
  Filters: [
    {
      Operator: '',
      Name: '',
      Value: ''
    }
  ],
  NextToken: '',
  MaxResults: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/accounts/:AwsAccountId/search/dashboards');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/search/dashboards',
  headers: {'content-type': 'application/json'},
  data: {Filters: [{Operator: '', Name: '', Value: ''}], NextToken: '', MaxResults: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/search/dashboards';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Filters":[{"Operator":"","Name":"","Value":""}],"NextToken":"","MaxResults":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/search/dashboards',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Filters": [\n    {\n      "Operator": "",\n      "Name": "",\n      "Value": ""\n    }\n  ],\n  "NextToken": "",\n  "MaxResults": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/search/dashboards")
  .post(body)
  .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/accounts/:AwsAccountId/search/dashboards',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Filters: [{Operator: '', Name: '', Value: ''}], NextToken: '', MaxResults: 0}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/search/dashboards',
  headers: {'content-type': 'application/json'},
  body: {Filters: [{Operator: '', Name: '', Value: ''}], NextToken: '', MaxResults: 0},
  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}}/accounts/:AwsAccountId/search/dashboards');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Filters: [
    {
      Operator: '',
      Name: '',
      Value: ''
    }
  ],
  NextToken: '',
  MaxResults: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/search/dashboards',
  headers: {'content-type': 'application/json'},
  data: {Filters: [{Operator: '', Name: '', Value: ''}], NextToken: '', MaxResults: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/search/dashboards';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Filters":[{"Operator":"","Name":"","Value":""}],"NextToken":"","MaxResults":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Filters": @[ @{ @"Operator": @"", @"Name": @"", @"Value": @"" } ],
                              @"NextToken": @"",
                              @"MaxResults": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/search/dashboards"]
                                                       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}}/accounts/:AwsAccountId/search/dashboards" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/search/dashboards",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Filters' => [
        [
                'Operator' => '',
                'Name' => '',
                'Value' => ''
        ]
    ],
    'NextToken' => '',
    'MaxResults' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/accounts/:AwsAccountId/search/dashboards', [
  'body' => '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/search/dashboards');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => [
    [
        'Operator' => '',
        'Name' => '',
        'Value' => ''
    ]
  ],
  'NextToken' => '',
  'MaxResults' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Filters' => [
    [
        'Operator' => '',
        'Name' => '',
        'Value' => ''
    ]
  ],
  'NextToken' => '',
  'MaxResults' => 0
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/search/dashboards');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/search/dashboards' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/search/dashboards' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/accounts/:AwsAccountId/search/dashboards", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/search/dashboards"

payload = {
    "Filters": [
        {
            "Operator": "",
            "Name": "",
            "Value": ""
        }
    ],
    "NextToken": "",
    "MaxResults": 0
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/search/dashboards"

payload <- "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/search/dashboards")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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/accounts/:AwsAccountId/search/dashboards') do |req|
  req.body = "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/search/dashboards";

    let payload = json!({
        "Filters": (
            json!({
                "Operator": "",
                "Name": "",
                "Value": ""
            })
        ),
        "NextToken": "",
        "MaxResults": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/accounts/:AwsAccountId/search/dashboards \
  --header 'content-type: application/json' \
  --data '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}'

echo '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}' |  \
  http POST {{baseUrl}}/accounts/:AwsAccountId/search/dashboards \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Filters": [\n    {\n      "Operator": "",\n      "Name": "",\n      "Value": ""\n    }\n  ],\n  "NextToken": "",\n  "MaxResults": 0\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/search/dashboards

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Filters": [
    [
      "Operator": "",
      "Name": "",
      "Value": ""
    ]
  ],
  "NextToken": "",
  "MaxResults": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/search/dashboards")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST SearchDataSets

{{baseUrl}}/accounts/:AwsAccountId/search/data-sets

QUERY PARAMS

AwsAccountId

BODY json

{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/search/data-sets");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/accounts/:AwsAccountId/search/data-sets" {:content-type :json
                                                                                    :form-params {:Filters [{:Operator ""
                                                                                                             :Name ""
                                                                                                             :Value ""}]
                                                                                                  :NextToken ""
                                                                                                  :MaxResults 0}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/search/data-sets"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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}}/accounts/:AwsAccountId/search/data-sets"),
    Content = new StringContent("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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}}/accounts/:AwsAccountId/search/data-sets");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/search/data-sets"

	payload := strings.NewReader("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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/accounts/:AwsAccountId/search/data-sets HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 130

{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:AwsAccountId/search/data-sets")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/search/data-sets"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/search/data-sets")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:AwsAccountId/search/data-sets")
  .header("content-type", "application/json")
  .body("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")
  .asString();

const data = JSON.stringify({
  Filters: [
    {
      Operator: '',
      Name: '',
      Value: ''
    }
  ],
  NextToken: '',
  MaxResults: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/accounts/:AwsAccountId/search/data-sets');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/search/data-sets',
  headers: {'content-type': 'application/json'},
  data: {Filters: [{Operator: '', Name: '', Value: ''}], NextToken: '', MaxResults: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/search/data-sets';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Filters":[{"Operator":"","Name":"","Value":""}],"NextToken":"","MaxResults":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/search/data-sets',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Filters": [\n    {\n      "Operator": "",\n      "Name": "",\n      "Value": ""\n    }\n  ],\n  "NextToken": "",\n  "MaxResults": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/search/data-sets")
  .post(body)
  .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/accounts/:AwsAccountId/search/data-sets',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Filters: [{Operator: '', Name: '', Value: ''}], NextToken: '', MaxResults: 0}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/search/data-sets',
  headers: {'content-type': 'application/json'},
  body: {Filters: [{Operator: '', Name: '', Value: ''}], NextToken: '', MaxResults: 0},
  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}}/accounts/:AwsAccountId/search/data-sets');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Filters: [
    {
      Operator: '',
      Name: '',
      Value: ''
    }
  ],
  NextToken: '',
  MaxResults: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/search/data-sets',
  headers: {'content-type': 'application/json'},
  data: {Filters: [{Operator: '', Name: '', Value: ''}], NextToken: '', MaxResults: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/search/data-sets';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Filters":[{"Operator":"","Name":"","Value":""}],"NextToken":"","MaxResults":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Filters": @[ @{ @"Operator": @"", @"Name": @"", @"Value": @"" } ],
                              @"NextToken": @"",
                              @"MaxResults": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/search/data-sets"]
                                                       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}}/accounts/:AwsAccountId/search/data-sets" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/search/data-sets",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Filters' => [
        [
                'Operator' => '',
                'Name' => '',
                'Value' => ''
        ]
    ],
    'NextToken' => '',
    'MaxResults' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/accounts/:AwsAccountId/search/data-sets', [
  'body' => '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/search/data-sets');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => [
    [
        'Operator' => '',
        'Name' => '',
        'Value' => ''
    ]
  ],
  'NextToken' => '',
  'MaxResults' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Filters' => [
    [
        'Operator' => '',
        'Name' => '',
        'Value' => ''
    ]
  ],
  'NextToken' => '',
  'MaxResults' => 0
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/search/data-sets');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/search/data-sets' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/search/data-sets' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/accounts/:AwsAccountId/search/data-sets", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/search/data-sets"

payload = {
    "Filters": [
        {
            "Operator": "",
            "Name": "",
            "Value": ""
        }
    ],
    "NextToken": "",
    "MaxResults": 0
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/search/data-sets"

payload <- "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/search/data-sets")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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/accounts/:AwsAccountId/search/data-sets') do |req|
  req.body = "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/search/data-sets";

    let payload = json!({
        "Filters": (
            json!({
                "Operator": "",
                "Name": "",
                "Value": ""
            })
        ),
        "NextToken": "",
        "MaxResults": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/accounts/:AwsAccountId/search/data-sets \
  --header 'content-type: application/json' \
  --data '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}'

echo '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}' |  \
  http POST {{baseUrl}}/accounts/:AwsAccountId/search/data-sets \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Filters": [\n    {\n      "Operator": "",\n      "Name": "",\n      "Value": ""\n    }\n  ],\n  "NextToken": "",\n  "MaxResults": 0\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/search/data-sets

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Filters": [
    [
      "Operator": "",
      "Name": "",
      "Value": ""
    ]
  ],
  "NextToken": "",
  "MaxResults": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/search/data-sets")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST SearchDataSources

{{baseUrl}}/accounts/:AwsAccountId/search/data-sources

QUERY PARAMS

AwsAccountId

BODY json

{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/search/data-sources");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/accounts/:AwsAccountId/search/data-sources" {:content-type :json
                                                                                       :form-params {:Filters [{:Operator ""
                                                                                                                :Name ""
                                                                                                                :Value ""}]
                                                                                                     :NextToken ""
                                                                                                     :MaxResults 0}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/search/data-sources"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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}}/accounts/:AwsAccountId/search/data-sources"),
    Content = new StringContent("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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}}/accounts/:AwsAccountId/search/data-sources");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/search/data-sources"

	payload := strings.NewReader("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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/accounts/:AwsAccountId/search/data-sources HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 130

{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:AwsAccountId/search/data-sources")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/search/data-sources"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/search/data-sources")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:AwsAccountId/search/data-sources")
  .header("content-type", "application/json")
  .body("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")
  .asString();

const data = JSON.stringify({
  Filters: [
    {
      Operator: '',
      Name: '',
      Value: ''
    }
  ],
  NextToken: '',
  MaxResults: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/accounts/:AwsAccountId/search/data-sources');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/search/data-sources',
  headers: {'content-type': 'application/json'},
  data: {Filters: [{Operator: '', Name: '', Value: ''}], NextToken: '', MaxResults: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/search/data-sources';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Filters":[{"Operator":"","Name":"","Value":""}],"NextToken":"","MaxResults":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/search/data-sources',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Filters": [\n    {\n      "Operator": "",\n      "Name": "",\n      "Value": ""\n    }\n  ],\n  "NextToken": "",\n  "MaxResults": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/search/data-sources")
  .post(body)
  .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/accounts/:AwsAccountId/search/data-sources',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Filters: [{Operator: '', Name: '', Value: ''}], NextToken: '', MaxResults: 0}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/search/data-sources',
  headers: {'content-type': 'application/json'},
  body: {Filters: [{Operator: '', Name: '', Value: ''}], NextToken: '', MaxResults: 0},
  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}}/accounts/:AwsAccountId/search/data-sources');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Filters: [
    {
      Operator: '',
      Name: '',
      Value: ''
    }
  ],
  NextToken: '',
  MaxResults: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/search/data-sources',
  headers: {'content-type': 'application/json'},
  data: {Filters: [{Operator: '', Name: '', Value: ''}], NextToken: '', MaxResults: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/search/data-sources';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Filters":[{"Operator":"","Name":"","Value":""}],"NextToken":"","MaxResults":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Filters": @[ @{ @"Operator": @"", @"Name": @"", @"Value": @"" } ],
                              @"NextToken": @"",
                              @"MaxResults": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/search/data-sources"]
                                                       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}}/accounts/:AwsAccountId/search/data-sources" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/search/data-sources",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Filters' => [
        [
                'Operator' => '',
                'Name' => '',
                'Value' => ''
        ]
    ],
    'NextToken' => '',
    'MaxResults' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/accounts/:AwsAccountId/search/data-sources', [
  'body' => '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/search/data-sources');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => [
    [
        'Operator' => '',
        'Name' => '',
        'Value' => ''
    ]
  ],
  'NextToken' => '',
  'MaxResults' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Filters' => [
    [
        'Operator' => '',
        'Name' => '',
        'Value' => ''
    ]
  ],
  'NextToken' => '',
  'MaxResults' => 0
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/search/data-sources');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/search/data-sources' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/search/data-sources' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/accounts/:AwsAccountId/search/data-sources", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/search/data-sources"

payload = {
    "Filters": [
        {
            "Operator": "",
            "Name": "",
            "Value": ""
        }
    ],
    "NextToken": "",
    "MaxResults": 0
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/search/data-sources"

payload <- "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/search/data-sources")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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/accounts/:AwsAccountId/search/data-sources') do |req|
  req.body = "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/search/data-sources";

    let payload = json!({
        "Filters": (
            json!({
                "Operator": "",
                "Name": "",
                "Value": ""
            })
        ),
        "NextToken": "",
        "MaxResults": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/accounts/:AwsAccountId/search/data-sources \
  --header 'content-type: application/json' \
  --data '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}'

echo '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}' |  \
  http POST {{baseUrl}}/accounts/:AwsAccountId/search/data-sources \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Filters": [\n    {\n      "Operator": "",\n      "Name": "",\n      "Value": ""\n    }\n  ],\n  "NextToken": "",\n  "MaxResults": 0\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/search/data-sources

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Filters": [
    [
      "Operator": "",
      "Name": "",
      "Value": ""
    ]
  ],
  "NextToken": "",
  "MaxResults": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/search/data-sources")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST SearchFolders

{{baseUrl}}/accounts/:AwsAccountId/search/folders

QUERY PARAMS

AwsAccountId

BODY json

{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/search/folders");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/accounts/:AwsAccountId/search/folders" {:content-type :json
                                                                                  :form-params {:Filters [{:Operator ""
                                                                                                           :Name ""
                                                                                                           :Value ""}]
                                                                                                :NextToken ""
                                                                                                :MaxResults 0}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/search/folders"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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}}/accounts/:AwsAccountId/search/folders"),
    Content = new StringContent("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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}}/accounts/:AwsAccountId/search/folders");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/search/folders"

	payload := strings.NewReader("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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/accounts/:AwsAccountId/search/folders HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 130

{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:AwsAccountId/search/folders")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/search/folders"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/search/folders")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:AwsAccountId/search/folders")
  .header("content-type", "application/json")
  .body("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")
  .asString();

const data = JSON.stringify({
  Filters: [
    {
      Operator: '',
      Name: '',
      Value: ''
    }
  ],
  NextToken: '',
  MaxResults: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/accounts/:AwsAccountId/search/folders');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/search/folders',
  headers: {'content-type': 'application/json'},
  data: {Filters: [{Operator: '', Name: '', Value: ''}], NextToken: '', MaxResults: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/search/folders';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Filters":[{"Operator":"","Name":"","Value":""}],"NextToken":"","MaxResults":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/search/folders',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Filters": [\n    {\n      "Operator": "",\n      "Name": "",\n      "Value": ""\n    }\n  ],\n  "NextToken": "",\n  "MaxResults": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/search/folders")
  .post(body)
  .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/accounts/:AwsAccountId/search/folders',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Filters: [{Operator: '', Name: '', Value: ''}], NextToken: '', MaxResults: 0}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/search/folders',
  headers: {'content-type': 'application/json'},
  body: {Filters: [{Operator: '', Name: '', Value: ''}], NextToken: '', MaxResults: 0},
  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}}/accounts/:AwsAccountId/search/folders');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Filters: [
    {
      Operator: '',
      Name: '',
      Value: ''
    }
  ],
  NextToken: '',
  MaxResults: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/search/folders',
  headers: {'content-type': 'application/json'},
  data: {Filters: [{Operator: '', Name: '', Value: ''}], NextToken: '', MaxResults: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/search/folders';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Filters":[{"Operator":"","Name":"","Value":""}],"NextToken":"","MaxResults":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Filters": @[ @{ @"Operator": @"", @"Name": @"", @"Value": @"" } ],
                              @"NextToken": @"",
                              @"MaxResults": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/search/folders"]
                                                       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}}/accounts/:AwsAccountId/search/folders" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/search/folders",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Filters' => [
        [
                'Operator' => '',
                'Name' => '',
                'Value' => ''
        ]
    ],
    'NextToken' => '',
    'MaxResults' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/accounts/:AwsAccountId/search/folders', [
  'body' => '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/search/folders');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => [
    [
        'Operator' => '',
        'Name' => '',
        'Value' => ''
    ]
  ],
  'NextToken' => '',
  'MaxResults' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Filters' => [
    [
        'Operator' => '',
        'Name' => '',
        'Value' => ''
    ]
  ],
  'NextToken' => '',
  'MaxResults' => 0
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/search/folders');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/search/folders' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/search/folders' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/accounts/:AwsAccountId/search/folders", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/search/folders"

payload = {
    "Filters": [
        {
            "Operator": "",
            "Name": "",
            "Value": ""
        }
    ],
    "NextToken": "",
    "MaxResults": 0
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/search/folders"

payload <- "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/search/folders")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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/accounts/:AwsAccountId/search/folders') do |req|
  req.body = "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/search/folders";

    let payload = json!({
        "Filters": (
            json!({
                "Operator": "",
                "Name": "",
                "Value": ""
            })
        ),
        "NextToken": "",
        "MaxResults": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/accounts/:AwsAccountId/search/folders \
  --header 'content-type: application/json' \
  --data '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}'

echo '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ],
  "NextToken": "",
  "MaxResults": 0
}' |  \
  http POST {{baseUrl}}/accounts/:AwsAccountId/search/folders \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Filters": [\n    {\n      "Operator": "",\n      "Name": "",\n      "Value": ""\n    }\n  ],\n  "NextToken": "",\n  "MaxResults": 0\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/search/folders

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Filters": [
    [
      "Operator": "",
      "Name": "",
      "Value": ""
    ]
  ],
  "NextToken": "",
  "MaxResults": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/search/folders")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST SearchGroups

{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search

QUERY PARAMS

AwsAccountId

Namespace

BODY json

{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search" {:content-type :json
                                                                                                       :form-params {:Filters [{:Operator ""
                                                                                                                                :Name ""
                                                                                                                                :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\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}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search"),
    Content = new StringContent("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\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}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search"

	payload := strings.NewReader("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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/accounts/:AwsAccountId/namespaces/:Namespace/groups-search HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 92

{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\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  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search")
  .header("content-type", "application/json")
  .body("{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  Filters: [
    {
      Operator: '',
      Name: '',
      Value: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search',
  headers: {'content-type': 'application/json'},
  data: {Filters: [{Operator: '', Name: '', Value: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Filters":[{"Operator":"","Name":"","Value":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Filters": [\n    {\n      "Operator": "",\n      "Name": "",\n      "Value": ""\n    }\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  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search")
  .post(body)
  .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/accounts/:AwsAccountId/namespaces/:Namespace/groups-search',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Filters: [{Operator: '', Name: '', Value: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search',
  headers: {'content-type': 'application/json'},
  body: {Filters: [{Operator: '', Name: '', Value: ''}]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Filters: [
    {
      Operator: '',
      Name: '',
      Value: ''
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search',
  headers: {'content-type': 'application/json'},
  data: {Filters: [{Operator: '', Name: '', Value: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Filters":[{"Operator":"","Name":"","Value":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Filters": @[ @{ @"Operator": @"", @"Name": @"", @"Value": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search"]
                                                       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}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Filters' => [
        [
                'Operator' => '',
                'Name' => '',
                'Value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search', [
  'body' => '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => [
    [
        'Operator' => '',
        'Name' => '',
        'Value' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Filters' => [
    [
        'Operator' => '',
        'Name' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups-search", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search"

payload = { "Filters": [
        {
            "Operator": "",
            "Name": "",
            "Value": ""
        }
    ] }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search"

payload <- "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\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/accounts/:AwsAccountId/namespaces/:Namespace/groups-search') do |req|
  req.body = "{\n  \"Filters\": [\n    {\n      \"Operator\": \"\",\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search";

    let payload = json!({"Filters": (
            json!({
                "Operator": "",
                "Name": "",
                "Value": ""
            })
        )});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search \
  --header 'content-type: application/json' \
  --data '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ]
}'

echo '{
  "Filters": [
    {
      "Operator": "",
      "Name": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Filters": [\n    {\n      "Operator": "",\n      "Name": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["Filters": [
    [
      "Operator": "",
      "Name": "",
      "Value": ""
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups-search")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST TagResource

{{baseUrl}}/resources/:ResourceArn/tags

QUERY PARAMS

ResourceArn

BODY json

{
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resources/:ResourceArn/tags");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/resources/:ResourceArn/tags" {:content-type :json
                                                                        :form-params {:Tags [{:Key ""
                                                                                              :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/resources/:ResourceArn/tags"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/resources/:ResourceArn/tags"),
    Content = new StringContent("{\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/resources/:ResourceArn/tags");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resources/:ResourceArn/tags"

	payload := strings.NewReader("{\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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/resources/:ResourceArn/tags HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 66

{
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/resources/:ResourceArn/tags")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resources/:ResourceArn/tags"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/resources/:ResourceArn/tags")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/resources/:ResourceArn/tags")
  .header("content-type", "application/json")
  .body("{\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/resources/:ResourceArn/tags');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/resources/:ResourceArn/tags',
  headers: {'content-type': 'application/json'},
  data: {Tags: [{Key: '', Value: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resources/:ResourceArn/tags';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Tags":[{"Key":"","Value":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resources/:ResourceArn/tags',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\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  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/resources/:ResourceArn/tags")
  .post(body)
  .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/resources/:ResourceArn/tags',
  headers: {
    '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({Tags: [{Key: '', Value: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/resources/:ResourceArn/tags',
  headers: {'content-type': 'application/json'},
  body: {Tags: [{Key: '', Value: ''}]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/resources/:ResourceArn/tags');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/resources/:ResourceArn/tags',
  headers: {'content-type': 'application/json'},
  data: {Tags: [{Key: '', Value: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resources/:ResourceArn/tags';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Tags":[{"Key":"","Value":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resources/:ResourceArn/tags"]
                                                       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}}/resources/:ResourceArn/tags" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resources/:ResourceArn/tags",
  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([
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/resources/:ResourceArn/tags', [
  'body' => '{
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/resources/:ResourceArn/tags');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/resources/:ResourceArn/tags');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/resources/:ResourceArn/tags' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/resources/:ResourceArn/tags' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/resources/:ResourceArn/tags", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resources/:ResourceArn/tags"

payload = { "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ] }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resources/:ResourceArn/tags"

payload <- "{\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resources/:ResourceArn/tags")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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/resources/:ResourceArn/tags') do |req|
  req.body = "{\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resources/:ResourceArn/tags";

    let payload = json!({"Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/resources/:ResourceArn/tags \
  --header 'content-type: application/json' \
  --data '{
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

echo '{
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/resources/:ResourceArn/tags \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/resources/:ResourceArn/tags

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resources/:ResourceArn/tags")! 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()

DELETE UntagResource

{{baseUrl}}/resources/:ResourceArn/tags#keys

QUERY PARAMS

keys

ResourceArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resources/:ResourceArn/tags?keys=#keys");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/resources/:ResourceArn/tags#keys" {:query-params {:keys ""}})

require "http/client"

url = "{{baseUrl}}/resources/:ResourceArn/tags?keys=#keys"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/resources/:ResourceArn/tags?keys=#keys"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/resources/:ResourceArn/tags?keys=#keys");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resources/:ResourceArn/tags?keys=#keys"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/resources/:ResourceArn/tags?keys= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/resources/:ResourceArn/tags?keys=#keys")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resources/:ResourceArn/tags?keys=#keys"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/resources/:ResourceArn/tags?keys=#keys")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/resources/:ResourceArn/tags?keys=#keys")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/resources/:ResourceArn/tags?keys=#keys');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/resources/:ResourceArn/tags#keys',
  params: {keys: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resources/:ResourceArn/tags?keys=#keys';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resources/:ResourceArn/tags?keys=#keys',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/resources/:ResourceArn/tags?keys=#keys")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resources/:ResourceArn/tags?keys=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/resources/:ResourceArn/tags#keys',
  qs: {keys: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/resources/:ResourceArn/tags#keys');

req.query({
  keys: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/resources/:ResourceArn/tags#keys',
  params: {keys: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resources/:ResourceArn/tags?keys=#keys';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resources/:ResourceArn/tags?keys=#keys"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resources/:ResourceArn/tags?keys=#keys" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resources/:ResourceArn/tags?keys=#keys",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/resources/:ResourceArn/tags?keys=#keys');

echo $response->getBody();

setUrl('{{baseUrl}}/resources/:ResourceArn/tags#keys');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'keys' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/resources/:ResourceArn/tags#keys');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'keys' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/resources/:ResourceArn/tags?keys=#keys' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/resources/:ResourceArn/tags?keys=#keys' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/resources/:ResourceArn/tags?keys=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resources/:ResourceArn/tags#keys"

querystring = {"keys":""}

response = requests.delete(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resources/:ResourceArn/tags#keys"

queryString <- list(keys = "")

response <- VERB("DELETE", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resources/:ResourceArn/tags?keys=#keys")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/resources/:ResourceArn/tags') do |req|
  req.params['keys'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resources/:ResourceArn/tags#keys";

    let querystring = [
        ("keys", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url '{{baseUrl}}/resources/:ResourceArn/tags?keys=#keys'

http DELETE '{{baseUrl}}/resources/:ResourceArn/tags?keys=#keys'

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/resources/:ResourceArn/tags?keys=#keys'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resources/:ResourceArn/tags?keys=#keys")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT UpdateAccountCustomization

{{baseUrl}}/accounts/:AwsAccountId/customizations

QUERY PARAMS

AwsAccountId

BODY json

{
  "AccountCustomization": {
    "DefaultTheme": "",
    "DefaultEmailCustomizationTemplate": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/customizations");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/accounts/:AwsAccountId/customizations" {:content-type :json
                                                                                 :form-params {:AccountCustomization {:DefaultTheme ""
                                                                                                                      :DefaultEmailCustomizationTemplate ""}}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/customizations"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\n  }\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/customizations"),
    Content = new StringContent("{\n  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\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}}/accounts/:AwsAccountId/customizations");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/customizations"

	payload := strings.NewReader("{\n  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\n  }\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	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))

}

PUT /baseUrl/accounts/:AwsAccountId/customizations HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 103

{
  "AccountCustomization": {
    "DefaultTheme": "",
    "DefaultEmailCustomizationTemplate": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/accounts/:AwsAccountId/customizations")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/customizations"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\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  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/customizations")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/accounts/:AwsAccountId/customizations")
  .header("content-type", "application/json")
  .body("{\n  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  AccountCustomization: {
    DefaultTheme: '',
    DefaultEmailCustomizationTemplate: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/accounts/:AwsAccountId/customizations');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/customizations',
  headers: {'content-type': 'application/json'},
  data: {
    AccountCustomization: {DefaultTheme: '', DefaultEmailCustomizationTemplate: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/customizations';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"AccountCustomization":{"DefaultTheme":"","DefaultEmailCustomizationTemplate":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/customizations',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AccountCustomization": {\n    "DefaultTheme": "",\n    "DefaultEmailCustomizationTemplate": ""\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  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/customizations")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/customizations',
  headers: {
    '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({
  AccountCustomization: {DefaultTheme: '', DefaultEmailCustomizationTemplate: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/customizations',
  headers: {'content-type': 'application/json'},
  body: {
    AccountCustomization: {DefaultTheme: '', DefaultEmailCustomizationTemplate: ''}
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/accounts/:AwsAccountId/customizations');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AccountCustomization: {
    DefaultTheme: '',
    DefaultEmailCustomizationTemplate: ''
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/customizations',
  headers: {'content-type': 'application/json'},
  data: {
    AccountCustomization: {DefaultTheme: '', DefaultEmailCustomizationTemplate: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/customizations';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"AccountCustomization":{"DefaultTheme":"","DefaultEmailCustomizationTemplate":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AccountCustomization": @{ @"DefaultTheme": @"", @"DefaultEmailCustomizationTemplate": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/customizations"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/accounts/:AwsAccountId/customizations" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/customizations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'AccountCustomization' => [
        'DefaultTheme' => '',
        'DefaultEmailCustomizationTemplate' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/accounts/:AwsAccountId/customizations', [
  'body' => '{
  "AccountCustomization": {
    "DefaultTheme": "",
    "DefaultEmailCustomizationTemplate": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/customizations');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AccountCustomization' => [
    'DefaultTheme' => '',
    'DefaultEmailCustomizationTemplate' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AccountCustomization' => [
    'DefaultTheme' => '',
    'DefaultEmailCustomizationTemplate' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/customizations');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/customizations' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "AccountCustomization": {
    "DefaultTheme": "",
    "DefaultEmailCustomizationTemplate": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/customizations' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "AccountCustomization": {
    "DefaultTheme": "",
    "DefaultEmailCustomizationTemplate": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/accounts/:AwsAccountId/customizations", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/customizations"

payload = { "AccountCustomization": {
        "DefaultTheme": "",
        "DefaultEmailCustomizationTemplate": ""
    } }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/customizations"

payload <- "{\n  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/customizations")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\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.put('/baseUrl/accounts/:AwsAccountId/customizations') do |req|
  req.body = "{\n  \"AccountCustomization\": {\n    \"DefaultTheme\": \"\",\n    \"DefaultEmailCustomizationTemplate\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/customizations";

    let payload = json!({"AccountCustomization": json!({
            "DefaultTheme": "",
            "DefaultEmailCustomizationTemplate": ""
        })});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/accounts/:AwsAccountId/customizations \
  --header 'content-type: application/json' \
  --data '{
  "AccountCustomization": {
    "DefaultTheme": "",
    "DefaultEmailCustomizationTemplate": ""
  }
}'

echo '{
  "AccountCustomization": {
    "DefaultTheme": "",
    "DefaultEmailCustomizationTemplate": ""
  }
}' |  \
  http PUT {{baseUrl}}/accounts/:AwsAccountId/customizations \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "AccountCustomization": {\n    "DefaultTheme": "",\n    "DefaultEmailCustomizationTemplate": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/customizations

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["AccountCustomization": [
    "DefaultTheme": "",
    "DefaultEmailCustomizationTemplate": ""
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/customizations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

PUT UpdateAccountSettings

{{baseUrl}}/accounts/:AwsAccountId/settings

QUERY PARAMS

AwsAccountId

BODY json

{
  "DefaultNamespace": "",
  "NotificationEmail": "",
  "TerminationProtectionEnabled": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/settings");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"DefaultNamespace\": \"\",\n  \"NotificationEmail\": \"\",\n  \"TerminationProtectionEnabled\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/accounts/:AwsAccountId/settings" {:content-type :json
                                                                           :form-params {:DefaultNamespace ""
                                                                                         :NotificationEmail ""
                                                                                         :TerminationProtectionEnabled false}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/settings"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"DefaultNamespace\": \"\",\n  \"NotificationEmail\": \"\",\n  \"TerminationProtectionEnabled\": false\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/settings"),
    Content = new StringContent("{\n  \"DefaultNamespace\": \"\",\n  \"NotificationEmail\": \"\",\n  \"TerminationProtectionEnabled\": false\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}}/accounts/:AwsAccountId/settings");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DefaultNamespace\": \"\",\n  \"NotificationEmail\": \"\",\n  \"TerminationProtectionEnabled\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/settings"

	payload := strings.NewReader("{\n  \"DefaultNamespace\": \"\",\n  \"NotificationEmail\": \"\",\n  \"TerminationProtectionEnabled\": false\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	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))

}

PUT /baseUrl/accounts/:AwsAccountId/settings HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 96

{
  "DefaultNamespace": "",
  "NotificationEmail": "",
  "TerminationProtectionEnabled": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/accounts/:AwsAccountId/settings")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DefaultNamespace\": \"\",\n  \"NotificationEmail\": \"\",\n  \"TerminationProtectionEnabled\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/settings"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"DefaultNamespace\": \"\",\n  \"NotificationEmail\": \"\",\n  \"TerminationProtectionEnabled\": false\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  \"DefaultNamespace\": \"\",\n  \"NotificationEmail\": \"\",\n  \"TerminationProtectionEnabled\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/settings")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/accounts/:AwsAccountId/settings")
  .header("content-type", "application/json")
  .body("{\n  \"DefaultNamespace\": \"\",\n  \"NotificationEmail\": \"\",\n  \"TerminationProtectionEnabled\": false\n}")
  .asString();

const data = JSON.stringify({
  DefaultNamespace: '',
  NotificationEmail: '',
  TerminationProtectionEnabled: false
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/accounts/:AwsAccountId/settings');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/settings',
  headers: {'content-type': 'application/json'},
  data: {
    DefaultNamespace: '',
    NotificationEmail: '',
    TerminationProtectionEnabled: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/settings';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"DefaultNamespace":"","NotificationEmail":"","TerminationProtectionEnabled":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/settings',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DefaultNamespace": "",\n  "NotificationEmail": "",\n  "TerminationProtectionEnabled": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DefaultNamespace\": \"\",\n  \"NotificationEmail\": \"\",\n  \"TerminationProtectionEnabled\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/settings")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/settings',
  headers: {
    '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({
  DefaultNamespace: '',
  NotificationEmail: '',
  TerminationProtectionEnabled: false
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/settings',
  headers: {'content-type': 'application/json'},
  body: {
    DefaultNamespace: '',
    NotificationEmail: '',
    TerminationProtectionEnabled: false
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/accounts/:AwsAccountId/settings');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  DefaultNamespace: '',
  NotificationEmail: '',
  TerminationProtectionEnabled: false
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/settings',
  headers: {'content-type': 'application/json'},
  data: {
    DefaultNamespace: '',
    NotificationEmail: '',
    TerminationProtectionEnabled: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/settings';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"DefaultNamespace":"","NotificationEmail":"","TerminationProtectionEnabled":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"DefaultNamespace": @"",
                              @"NotificationEmail": @"",
                              @"TerminationProtectionEnabled": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/settings"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/accounts/:AwsAccountId/settings" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"DefaultNamespace\": \"\",\n  \"NotificationEmail\": \"\",\n  \"TerminationProtectionEnabled\": false\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/settings",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'DefaultNamespace' => '',
    'NotificationEmail' => '',
    'TerminationProtectionEnabled' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/accounts/:AwsAccountId/settings', [
  'body' => '{
  "DefaultNamespace": "",
  "NotificationEmail": "",
  "TerminationProtectionEnabled": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/settings');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DefaultNamespace' => '',
  'NotificationEmail' => '',
  'TerminationProtectionEnabled' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'DefaultNamespace' => '',
  'NotificationEmail' => '',
  'TerminationProtectionEnabled' => null
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/settings');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/settings' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "DefaultNamespace": "",
  "NotificationEmail": "",
  "TerminationProtectionEnabled": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/settings' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "DefaultNamespace": "",
  "NotificationEmail": "",
  "TerminationProtectionEnabled": false
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"DefaultNamespace\": \"\",\n  \"NotificationEmail\": \"\",\n  \"TerminationProtectionEnabled\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/accounts/:AwsAccountId/settings", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/settings"

payload = {
    "DefaultNamespace": "",
    "NotificationEmail": "",
    "TerminationProtectionEnabled": False
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/settings"

payload <- "{\n  \"DefaultNamespace\": \"\",\n  \"NotificationEmail\": \"\",\n  \"TerminationProtectionEnabled\": false\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/settings")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"DefaultNamespace\": \"\",\n  \"NotificationEmail\": \"\",\n  \"TerminationProtectionEnabled\": false\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.put('/baseUrl/accounts/:AwsAccountId/settings') do |req|
  req.body = "{\n  \"DefaultNamespace\": \"\",\n  \"NotificationEmail\": \"\",\n  \"TerminationProtectionEnabled\": false\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/settings";

    let payload = json!({
        "DefaultNamespace": "",
        "NotificationEmail": "",
        "TerminationProtectionEnabled": false
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/accounts/:AwsAccountId/settings \
  --header 'content-type: application/json' \
  --data '{
  "DefaultNamespace": "",
  "NotificationEmail": "",
  "TerminationProtectionEnabled": false
}'

echo '{
  "DefaultNamespace": "",
  "NotificationEmail": "",
  "TerminationProtectionEnabled": false
}' |  \
  http PUT {{baseUrl}}/accounts/:AwsAccountId/settings \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "DefaultNamespace": "",\n  "NotificationEmail": "",\n  "TerminationProtectionEnabled": false\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/settings

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "DefaultNamespace": "",
  "NotificationEmail": "",
  "TerminationProtectionEnabled": false
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/settings")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

PUT UpdateAnalysis

{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId

QUERY PARAMS

AwsAccountId

AnalysisId

BODY json

{
  "Name": "",
  "Parameters": {
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  },
  "SourceEntity": {
    "SourceTemplate": ""
  },
  "ThemeArn": "",
  "Definition": {
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId");

struct curl_slist *headers = NULL;
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  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId" {:content-type :json
                                                                                       :form-params {:Name ""
                                                                                                     :Parameters {:StringParameters ""
                                                                                                                  :IntegerParameters ""
                                                                                                                  :DecimalParameters ""
                                                                                                                  :DateTimeParameters ""}
                                                                                                     :SourceEntity {:SourceTemplate ""}
                                                                                                     :ThemeArn ""
                                                                                                     :Definition {:DataSetIdentifierDeclarations ""
                                                                                                                  :Sheets ""
                                                                                                                  :CalculatedFields ""
                                                                                                                  :ParameterDeclarations ""
                                                                                                                  :FilterGroups ""
                                                                                                                  :ColumnConfigurations ""
                                                                                                                  :AnalysisDefaults {:DefaultNewSheetConfiguration ""}}}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\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}}/accounts/:AwsAccountId/analyses/:AnalysisId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	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))

}

PUT /baseUrl/accounts/:AwsAccountId/analyses/:AnalysisId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 494

{
  "Name": "",
  "Parameters": {
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  },
  "SourceEntity": {
    "SourceTemplate": ""
  },
  "ThemeArn": "",
  "Definition": {
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\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  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Parameters: {
    StringParameters: '',
    IntegerParameters: '',
    DecimalParameters: '',
    DateTimeParameters: ''
  },
  SourceEntity: {
    SourceTemplate: ''
  },
  ThemeArn: '',
  Definition: {
    DataSetIdentifierDeclarations: '',
    Sheets: '',
    CalculatedFields: '',
    ParameterDeclarations: '',
    FilterGroups: '',
    ColumnConfigurations: '',
    AnalysisDefaults: {
      DefaultNewSheetConfiguration: ''
    }
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Parameters: {
      StringParameters: '',
      IntegerParameters: '',
      DecimalParameters: '',
      DateTimeParameters: ''
    },
    SourceEntity: {SourceTemplate: ''},
    ThemeArn: '',
    Definition: {
      DataSetIdentifierDeclarations: '',
      Sheets: '',
      CalculatedFields: '',
      ParameterDeclarations: '',
      FilterGroups: '',
      ColumnConfigurations: '',
      AnalysisDefaults: {DefaultNewSheetConfiguration: ''}
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Parameters":{"StringParameters":"","IntegerParameters":"","DecimalParameters":"","DateTimeParameters":""},"SourceEntity":{"SourceTemplate":""},"ThemeArn":"","Definition":{"DataSetIdentifierDeclarations":"","Sheets":"","CalculatedFields":"","ParameterDeclarations":"","FilterGroups":"","ColumnConfigurations":"","AnalysisDefaults":{"DefaultNewSheetConfiguration":""}}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Parameters": {\n    "StringParameters": "",\n    "IntegerParameters": "",\n    "DecimalParameters": "",\n    "DateTimeParameters": ""\n  },\n  "SourceEntity": {\n    "SourceTemplate": ""\n  },\n  "ThemeArn": "",\n  "Definition": {\n    "DataSetIdentifierDeclarations": "",\n    "Sheets": "",\n    "CalculatedFields": "",\n    "ParameterDeclarations": "",\n    "FilterGroups": "",\n    "ColumnConfigurations": "",\n    "AnalysisDefaults": {\n      "DefaultNewSheetConfiguration": ""\n    }\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  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/analyses/:AnalysisId',
  headers: {
    '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: '',
  Parameters: {
    StringParameters: '',
    IntegerParameters: '',
    DecimalParameters: '',
    DateTimeParameters: ''
  },
  SourceEntity: {SourceTemplate: ''},
  ThemeArn: '',
  Definition: {
    DataSetIdentifierDeclarations: '',
    Sheets: '',
    CalculatedFields: '',
    ParameterDeclarations: '',
    FilterGroups: '',
    ColumnConfigurations: '',
    AnalysisDefaults: {DefaultNewSheetConfiguration: ''}
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId',
  headers: {'content-type': 'application/json'},
  body: {
    Name: '',
    Parameters: {
      StringParameters: '',
      IntegerParameters: '',
      DecimalParameters: '',
      DateTimeParameters: ''
    },
    SourceEntity: {SourceTemplate: ''},
    ThemeArn: '',
    Definition: {
      DataSetIdentifierDeclarations: '',
      Sheets: '',
      CalculatedFields: '',
      ParameterDeclarations: '',
      FilterGroups: '',
      ColumnConfigurations: '',
      AnalysisDefaults: {DefaultNewSheetConfiguration: ''}
    }
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: '',
  Parameters: {
    StringParameters: '',
    IntegerParameters: '',
    DecimalParameters: '',
    DateTimeParameters: ''
  },
  SourceEntity: {
    SourceTemplate: ''
  },
  ThemeArn: '',
  Definition: {
    DataSetIdentifierDeclarations: '',
    Sheets: '',
    CalculatedFields: '',
    ParameterDeclarations: '',
    FilterGroups: '',
    ColumnConfigurations: '',
    AnalysisDefaults: {
      DefaultNewSheetConfiguration: ''
    }
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Parameters: {
      StringParameters: '',
      IntegerParameters: '',
      DecimalParameters: '',
      DateTimeParameters: ''
    },
    SourceEntity: {SourceTemplate: ''},
    ThemeArn: '',
    Definition: {
      DataSetIdentifierDeclarations: '',
      Sheets: '',
      CalculatedFields: '',
      ParameterDeclarations: '',
      FilterGroups: '',
      ColumnConfigurations: '',
      AnalysisDefaults: {DefaultNewSheetConfiguration: ''}
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Parameters":{"StringParameters":"","IntegerParameters":"","DecimalParameters":"","DateTimeParameters":""},"SourceEntity":{"SourceTemplate":""},"ThemeArn":"","Definition":{"DataSetIdentifierDeclarations":"","Sheets":"","CalculatedFields":"","ParameterDeclarations":"","FilterGroups":"","ColumnConfigurations":"","AnalysisDefaults":{"DefaultNewSheetConfiguration":""}}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"Parameters": @{ @"StringParameters": @"", @"IntegerParameters": @"", @"DecimalParameters": @"", @"DateTimeParameters": @"" },
                              @"SourceEntity": @{ @"SourceTemplate": @"" },
                              @"ThemeArn": @"",
                              @"Definition": @{ @"DataSetIdentifierDeclarations": @"", @"Sheets": @"", @"CalculatedFields": @"", @"ParameterDeclarations": @"", @"FilterGroups": @"", @"ColumnConfigurations": @"", @"AnalysisDefaults": @{ @"DefaultNewSheetConfiguration": @"" } } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/accounts/:AwsAccountId/analyses/:AnalysisId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'Parameters' => [
        'StringParameters' => '',
        'IntegerParameters' => '',
        'DecimalParameters' => '',
        'DateTimeParameters' => ''
    ],
    'SourceEntity' => [
        'SourceTemplate' => ''
    ],
    'ThemeArn' => '',
    'Definition' => [
        'DataSetIdentifierDeclarations' => '',
        'Sheets' => '',
        'CalculatedFields' => '',
        'ParameterDeclarations' => '',
        'FilterGroups' => '',
        'ColumnConfigurations' => '',
        'AnalysisDefaults' => [
                'DefaultNewSheetConfiguration' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId', [
  'body' => '{
  "Name": "",
  "Parameters": {
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  },
  "SourceEntity": {
    "SourceTemplate": ""
  },
  "ThemeArn": "",
  "Definition": {
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Parameters' => [
    'StringParameters' => '',
    'IntegerParameters' => '',
    'DecimalParameters' => '',
    'DateTimeParameters' => ''
  ],
  'SourceEntity' => [
    'SourceTemplate' => ''
  ],
  'ThemeArn' => '',
  'Definition' => [
    'DataSetIdentifierDeclarations' => '',
    'Sheets' => '',
    'CalculatedFields' => '',
    'ParameterDeclarations' => '',
    'FilterGroups' => '',
    'ColumnConfigurations' => '',
    'AnalysisDefaults' => [
        'DefaultNewSheetConfiguration' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => '',
  'Parameters' => [
    'StringParameters' => '',
    'IntegerParameters' => '',
    'DecimalParameters' => '',
    'DateTimeParameters' => ''
  ],
  'SourceEntity' => [
    'SourceTemplate' => ''
  ],
  'ThemeArn' => '',
  'Definition' => [
    'DataSetIdentifierDeclarations' => '',
    'Sheets' => '',
    'CalculatedFields' => '',
    'ParameterDeclarations' => '',
    'FilterGroups' => '',
    'ColumnConfigurations' => '',
    'AnalysisDefaults' => [
        'DefaultNewSheetConfiguration' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Parameters": {
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  },
  "SourceEntity": {
    "SourceTemplate": ""
  },
  "ThemeArn": "",
  "Definition": {
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Parameters": {
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  },
  "SourceEntity": {
    "SourceTemplate": ""
  },
  "ThemeArn": "",
  "Definition": {
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/accounts/:AwsAccountId/analyses/:AnalysisId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId"

payload = {
    "Name": "",
    "Parameters": {
        "StringParameters": "",
        "IntegerParameters": "",
        "DecimalParameters": "",
        "DateTimeParameters": ""
    },
    "SourceEntity": { "SourceTemplate": "" },
    "ThemeArn": "",
    "Definition": {
        "DataSetIdentifierDeclarations": "",
        "Sheets": "",
        "CalculatedFields": "",
        "ParameterDeclarations": "",
        "FilterGroups": "",
        "ColumnConfigurations": "",
        "AnalysisDefaults": { "DefaultNewSheetConfiguration": "" }
    }
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId"

payload <- "{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\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.put('/baseUrl/accounts/:AwsAccountId/analyses/:AnalysisId') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId";

    let payload = json!({
        "Name": "",
        "Parameters": json!({
            "StringParameters": "",
            "IntegerParameters": "",
            "DecimalParameters": "",
            "DateTimeParameters": ""
        }),
        "SourceEntity": json!({"SourceTemplate": ""}),
        "ThemeArn": "",
        "Definition": json!({
            "DataSetIdentifierDeclarations": "",
            "Sheets": "",
            "CalculatedFields": "",
            "ParameterDeclarations": "",
            "FilterGroups": "",
            "ColumnConfigurations": "",
            "AnalysisDefaults": json!({"DefaultNewSheetConfiguration": ""})
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId \
  --header 'content-type: application/json' \
  --data '{
  "Name": "",
  "Parameters": {
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  },
  "SourceEntity": {
    "SourceTemplate": ""
  },
  "ThemeArn": "",
  "Definition": {
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}'

echo '{
  "Name": "",
  "Parameters": {
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  },
  "SourceEntity": {
    "SourceTemplate": ""
  },
  "ThemeArn": "",
  "Definition": {
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}' |  \
  http PUT {{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Parameters": {\n    "StringParameters": "",\n    "IntegerParameters": "",\n    "DecimalParameters": "",\n    "DateTimeParameters": ""\n  },\n  "SourceEntity": {\n    "SourceTemplate": ""\n  },\n  "ThemeArn": "",\n  "Definition": {\n    "DataSetIdentifierDeclarations": "",\n    "Sheets": "",\n    "CalculatedFields": "",\n    "ParameterDeclarations": "",\n    "FilterGroups": "",\n    "ColumnConfigurations": "",\n    "AnalysisDefaults": {\n      "DefaultNewSheetConfiguration": ""\n    }\n  }\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "Parameters": [
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  ],
  "SourceEntity": ["SourceTemplate": ""],
  "ThemeArn": "",
  "Definition": [
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": ["DefaultNewSheetConfiguration": ""]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

PUT UpdateAnalysisPermissions

{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions

QUERY PARAMS

AwsAccountId

AnalysisId

BODY json

{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions" {:content-type :json
                                                                                                   :form-params {:GrantPermissions [{:Principal ""
                                                                                                                                     :Actions ""}]
                                                                                                                 :RevokePermissions [{}]}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions"),
    Content = new StringContent("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\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}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions"

	payload := strings.NewReader("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	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))

}

PUT /baseUrl/accounts/:AwsAccountId/analyses/:AnalysisId/permissions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 123

{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\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  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions")
  .header("content-type", "application/json")
  .body("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}")
  .asString();

const data = JSON.stringify({
  GrantPermissions: [
    {
      Principal: '',
      Actions: ''
    }
  ],
  RevokePermissions: [
    {}
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions',
  headers: {'content-type': 'application/json'},
  data: {GrantPermissions: [{Principal: '', Actions: ''}], RevokePermissions: [{}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"GrantPermissions":[{"Principal":"","Actions":""}],"RevokePermissions":[{}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GrantPermissions": [\n    {\n      "Principal": "",\n      "Actions": ""\n    }\n  ],\n  "RevokePermissions": [\n    {}\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  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/analyses/:AnalysisId/permissions',
  headers: {
    '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({GrantPermissions: [{Principal: '', Actions: ''}], RevokePermissions: [{}]}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions',
  headers: {'content-type': 'application/json'},
  body: {GrantPermissions: [{Principal: '', Actions: ''}], RevokePermissions: [{}]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GrantPermissions: [
    {
      Principal: '',
      Actions: ''
    }
  ],
  RevokePermissions: [
    {}
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions',
  headers: {'content-type': 'application/json'},
  data: {GrantPermissions: [{Principal: '', Actions: ''}], RevokePermissions: [{}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"GrantPermissions":[{"Principal":"","Actions":""}],"RevokePermissions":[{}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GrantPermissions": @[ @{ @"Principal": @"", @"Actions": @"" } ],
                              @"RevokePermissions": @[ @{  } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'GrantPermissions' => [
        [
                'Principal' => '',
                'Actions' => ''
        ]
    ],
    'RevokePermissions' => [
        [
                
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions', [
  'body' => '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GrantPermissions' => [
    [
        'Principal' => '',
        'Actions' => ''
    ]
  ],
  'RevokePermissions' => [
    [
        
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GrantPermissions' => [
    [
        'Principal' => '',
        'Actions' => ''
    ]
  ],
  'RevokePermissions' => [
    [
        
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/accounts/:AwsAccountId/analyses/:AnalysisId/permissions", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions"

payload = {
    "GrantPermissions": [
        {
            "Principal": "",
            "Actions": ""
        }
    ],
    "RevokePermissions": [{}]
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions"

payload <- "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\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.put('/baseUrl/accounts/:AwsAccountId/analyses/:AnalysisId/permissions') do |req|
  req.body = "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions";

    let payload = json!({
        "GrantPermissions": (
            json!({
                "Principal": "",
                "Actions": ""
            })
        ),
        "RevokePermissions": (json!({}))
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions \
  --header 'content-type: application/json' \
  --data '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}'

echo '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}' |  \
  http PUT {{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "GrantPermissions": [\n    {\n      "Principal": "",\n      "Actions": ""\n    }\n  ],\n  "RevokePermissions": [\n    {}\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "GrantPermissions": [
    [
      "Principal": "",
      "Actions": ""
    ]
  ],
  "RevokePermissions": [[]]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/analyses/:AnalysisId/permissions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

PUT UpdateDashboard

{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId

QUERY PARAMS

AwsAccountId

DashboardId

BODY json

{
  "Name": "",
  "SourceEntity": {
    "SourceTemplate": ""
  },
  "Parameters": {
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  },
  "VersionDescription": "",
  "DashboardPublishOptions": {
    "AdHocFilteringOption": "",
    "ExportToCSVOption": "",
    "SheetControlsOption": "",
    "VisualPublishOptions": "",
    "SheetLayoutElementMaximizationOption": "",
    "VisualMenuOption": "",
    "VisualAxisSortOption": "",
    "ExportWithHiddenFieldsOption": "",
    "DataPointDrillUpDownOption": "",
    "DataPointMenuLabelOption": "",
    "DataPointTooltipOption": ""
  },
  "ThemeArn": "",
  "Definition": {
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId");

struct curl_slist *headers = NULL;
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  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId" {:content-type :json
                                                                                          :form-params {:Name ""
                                                                                                        :SourceEntity {:SourceTemplate ""}
                                                                                                        :Parameters {:StringParameters ""
                                                                                                                     :IntegerParameters ""
                                                                                                                     :DecimalParameters ""
                                                                                                                     :DateTimeParameters ""}
                                                                                                        :VersionDescription ""
                                                                                                        :DashboardPublishOptions {:AdHocFilteringOption ""
                                                                                                                                  :ExportToCSVOption ""
                                                                                                                                  :SheetControlsOption ""
                                                                                                                                  :VisualPublishOptions ""
                                                                                                                                  :SheetLayoutElementMaximizationOption ""
                                                                                                                                  :VisualMenuOption ""
                                                                                                                                  :VisualAxisSortOption ""
                                                                                                                                  :ExportWithHiddenFieldsOption ""
                                                                                                                                  :DataPointDrillUpDownOption ""
                                                                                                                                  :DataPointMenuLabelOption ""
                                                                                                                                  :DataPointTooltipOption ""}
                                                                                                        :ThemeArn ""
                                                                                                        :Definition {:DataSetIdentifierDeclarations ""
                                                                                                                     :Sheets ""
                                                                                                                     :CalculatedFields ""
                                                                                                                     :ParameterDeclarations ""
                                                                                                                     :FilterGroups ""
                                                                                                                     :ColumnConfigurations ""
                                                                                                                     :AnalysisDefaults {:DefaultNewSheetConfiguration ""}}}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\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}}/accounts/:AwsAccountId/dashboards/:DashboardId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	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))

}

PUT /baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 937

{
  "Name": "",
  "SourceEntity": {
    "SourceTemplate": ""
  },
  "Parameters": {
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  },
  "VersionDescription": "",
  "DashboardPublishOptions": {
    "AdHocFilteringOption": "",
    "ExportToCSVOption": "",
    "SheetControlsOption": "",
    "VisualPublishOptions": "",
    "SheetLayoutElementMaximizationOption": "",
    "VisualMenuOption": "",
    "VisualAxisSortOption": "",
    "ExportWithHiddenFieldsOption": "",
    "DataPointDrillUpDownOption": "",
    "DataPointMenuLabelOption": "",
    "DataPointTooltipOption": ""
  },
  "ThemeArn": "",
  "Definition": {
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\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  \"Name\": \"\",\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  SourceEntity: {
    SourceTemplate: ''
  },
  Parameters: {
    StringParameters: '',
    IntegerParameters: '',
    DecimalParameters: '',
    DateTimeParameters: ''
  },
  VersionDescription: '',
  DashboardPublishOptions: {
    AdHocFilteringOption: '',
    ExportToCSVOption: '',
    SheetControlsOption: '',
    VisualPublishOptions: '',
    SheetLayoutElementMaximizationOption: '',
    VisualMenuOption: '',
    VisualAxisSortOption: '',
    ExportWithHiddenFieldsOption: '',
    DataPointDrillUpDownOption: '',
    DataPointMenuLabelOption: '',
    DataPointTooltipOption: ''
  },
  ThemeArn: '',
  Definition: {
    DataSetIdentifierDeclarations: '',
    Sheets: '',
    CalculatedFields: '',
    ParameterDeclarations: '',
    FilterGroups: '',
    ColumnConfigurations: '',
    AnalysisDefaults: {
      DefaultNewSheetConfiguration: ''
    }
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    SourceEntity: {SourceTemplate: ''},
    Parameters: {
      StringParameters: '',
      IntegerParameters: '',
      DecimalParameters: '',
      DateTimeParameters: ''
    },
    VersionDescription: '',
    DashboardPublishOptions: {
      AdHocFilteringOption: '',
      ExportToCSVOption: '',
      SheetControlsOption: '',
      VisualPublishOptions: '',
      SheetLayoutElementMaximizationOption: '',
      VisualMenuOption: '',
      VisualAxisSortOption: '',
      ExportWithHiddenFieldsOption: '',
      DataPointDrillUpDownOption: '',
      DataPointMenuLabelOption: '',
      DataPointTooltipOption: ''
    },
    ThemeArn: '',
    Definition: {
      DataSetIdentifierDeclarations: '',
      Sheets: '',
      CalculatedFields: '',
      ParameterDeclarations: '',
      FilterGroups: '',
      ColumnConfigurations: '',
      AnalysisDefaults: {DefaultNewSheetConfiguration: ''}
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","SourceEntity":{"SourceTemplate":""},"Parameters":{"StringParameters":"","IntegerParameters":"","DecimalParameters":"","DateTimeParameters":""},"VersionDescription":"","DashboardPublishOptions":{"AdHocFilteringOption":"","ExportToCSVOption":"","SheetControlsOption":"","VisualPublishOptions":"","SheetLayoutElementMaximizationOption":"","VisualMenuOption":"","VisualAxisSortOption":"","ExportWithHiddenFieldsOption":"","DataPointDrillUpDownOption":"","DataPointMenuLabelOption":"","DataPointTooltipOption":""},"ThemeArn":"","Definition":{"DataSetIdentifierDeclarations":"","Sheets":"","CalculatedFields":"","ParameterDeclarations":"","FilterGroups":"","ColumnConfigurations":"","AnalysisDefaults":{"DefaultNewSheetConfiguration":""}}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "SourceEntity": {\n    "SourceTemplate": ""\n  },\n  "Parameters": {\n    "StringParameters": "",\n    "IntegerParameters": "",\n    "DecimalParameters": "",\n    "DateTimeParameters": ""\n  },\n  "VersionDescription": "",\n  "DashboardPublishOptions": {\n    "AdHocFilteringOption": "",\n    "ExportToCSVOption": "",\n    "SheetControlsOption": "",\n    "VisualPublishOptions": "",\n    "SheetLayoutElementMaximizationOption": "",\n    "VisualMenuOption": "",\n    "VisualAxisSortOption": "",\n    "ExportWithHiddenFieldsOption": "",\n    "DataPointDrillUpDownOption": "",\n    "DataPointMenuLabelOption": "",\n    "DataPointTooltipOption": ""\n  },\n  "ThemeArn": "",\n  "Definition": {\n    "DataSetIdentifierDeclarations": "",\n    "Sheets": "",\n    "CalculatedFields": "",\n    "ParameterDeclarations": "",\n    "FilterGroups": "",\n    "ColumnConfigurations": "",\n    "AnalysisDefaults": {\n      "DefaultNewSheetConfiguration": ""\n    }\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  \"Name\": \"\",\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId',
  headers: {
    '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: '',
  SourceEntity: {SourceTemplate: ''},
  Parameters: {
    StringParameters: '',
    IntegerParameters: '',
    DecimalParameters: '',
    DateTimeParameters: ''
  },
  VersionDescription: '',
  DashboardPublishOptions: {
    AdHocFilteringOption: '',
    ExportToCSVOption: '',
    SheetControlsOption: '',
    VisualPublishOptions: '',
    SheetLayoutElementMaximizationOption: '',
    VisualMenuOption: '',
    VisualAxisSortOption: '',
    ExportWithHiddenFieldsOption: '',
    DataPointDrillUpDownOption: '',
    DataPointMenuLabelOption: '',
    DataPointTooltipOption: ''
  },
  ThemeArn: '',
  Definition: {
    DataSetIdentifierDeclarations: '',
    Sheets: '',
    CalculatedFields: '',
    ParameterDeclarations: '',
    FilterGroups: '',
    ColumnConfigurations: '',
    AnalysisDefaults: {DefaultNewSheetConfiguration: ''}
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId',
  headers: {'content-type': 'application/json'},
  body: {
    Name: '',
    SourceEntity: {SourceTemplate: ''},
    Parameters: {
      StringParameters: '',
      IntegerParameters: '',
      DecimalParameters: '',
      DateTimeParameters: ''
    },
    VersionDescription: '',
    DashboardPublishOptions: {
      AdHocFilteringOption: '',
      ExportToCSVOption: '',
      SheetControlsOption: '',
      VisualPublishOptions: '',
      SheetLayoutElementMaximizationOption: '',
      VisualMenuOption: '',
      VisualAxisSortOption: '',
      ExportWithHiddenFieldsOption: '',
      DataPointDrillUpDownOption: '',
      DataPointMenuLabelOption: '',
      DataPointTooltipOption: ''
    },
    ThemeArn: '',
    Definition: {
      DataSetIdentifierDeclarations: '',
      Sheets: '',
      CalculatedFields: '',
      ParameterDeclarations: '',
      FilterGroups: '',
      ColumnConfigurations: '',
      AnalysisDefaults: {DefaultNewSheetConfiguration: ''}
    }
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: '',
  SourceEntity: {
    SourceTemplate: ''
  },
  Parameters: {
    StringParameters: '',
    IntegerParameters: '',
    DecimalParameters: '',
    DateTimeParameters: ''
  },
  VersionDescription: '',
  DashboardPublishOptions: {
    AdHocFilteringOption: '',
    ExportToCSVOption: '',
    SheetControlsOption: '',
    VisualPublishOptions: '',
    SheetLayoutElementMaximizationOption: '',
    VisualMenuOption: '',
    VisualAxisSortOption: '',
    ExportWithHiddenFieldsOption: '',
    DataPointDrillUpDownOption: '',
    DataPointMenuLabelOption: '',
    DataPointTooltipOption: ''
  },
  ThemeArn: '',
  Definition: {
    DataSetIdentifierDeclarations: '',
    Sheets: '',
    CalculatedFields: '',
    ParameterDeclarations: '',
    FilterGroups: '',
    ColumnConfigurations: '',
    AnalysisDefaults: {
      DefaultNewSheetConfiguration: ''
    }
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    SourceEntity: {SourceTemplate: ''},
    Parameters: {
      StringParameters: '',
      IntegerParameters: '',
      DecimalParameters: '',
      DateTimeParameters: ''
    },
    VersionDescription: '',
    DashboardPublishOptions: {
      AdHocFilteringOption: '',
      ExportToCSVOption: '',
      SheetControlsOption: '',
      VisualPublishOptions: '',
      SheetLayoutElementMaximizationOption: '',
      VisualMenuOption: '',
      VisualAxisSortOption: '',
      ExportWithHiddenFieldsOption: '',
      DataPointDrillUpDownOption: '',
      DataPointMenuLabelOption: '',
      DataPointTooltipOption: ''
    },
    ThemeArn: '',
    Definition: {
      DataSetIdentifierDeclarations: '',
      Sheets: '',
      CalculatedFields: '',
      ParameterDeclarations: '',
      FilterGroups: '',
      ColumnConfigurations: '',
      AnalysisDefaults: {DefaultNewSheetConfiguration: ''}
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","SourceEntity":{"SourceTemplate":""},"Parameters":{"StringParameters":"","IntegerParameters":"","DecimalParameters":"","DateTimeParameters":""},"VersionDescription":"","DashboardPublishOptions":{"AdHocFilteringOption":"","ExportToCSVOption":"","SheetControlsOption":"","VisualPublishOptions":"","SheetLayoutElementMaximizationOption":"","VisualMenuOption":"","VisualAxisSortOption":"","ExportWithHiddenFieldsOption":"","DataPointDrillUpDownOption":"","DataPointMenuLabelOption":"","DataPointTooltipOption":""},"ThemeArn":"","Definition":{"DataSetIdentifierDeclarations":"","Sheets":"","CalculatedFields":"","ParameterDeclarations":"","FilterGroups":"","ColumnConfigurations":"","AnalysisDefaults":{"DefaultNewSheetConfiguration":""}}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"SourceEntity": @{ @"SourceTemplate": @"" },
                              @"Parameters": @{ @"StringParameters": @"", @"IntegerParameters": @"", @"DecimalParameters": @"", @"DateTimeParameters": @"" },
                              @"VersionDescription": @"",
                              @"DashboardPublishOptions": @{ @"AdHocFilteringOption": @"", @"ExportToCSVOption": @"", @"SheetControlsOption": @"", @"VisualPublishOptions": @"", @"SheetLayoutElementMaximizationOption": @"", @"VisualMenuOption": @"", @"VisualAxisSortOption": @"", @"ExportWithHiddenFieldsOption": @"", @"DataPointDrillUpDownOption": @"", @"DataPointMenuLabelOption": @"", @"DataPointTooltipOption": @"" },
                              @"ThemeArn": @"",
                              @"Definition": @{ @"DataSetIdentifierDeclarations": @"", @"Sheets": @"", @"CalculatedFields": @"", @"ParameterDeclarations": @"", @"FilterGroups": @"", @"ColumnConfigurations": @"", @"AnalysisDefaults": @{ @"DefaultNewSheetConfiguration": @"" } } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/accounts/:AwsAccountId/dashboards/:DashboardId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'SourceEntity' => [
        'SourceTemplate' => ''
    ],
    'Parameters' => [
        'StringParameters' => '',
        'IntegerParameters' => '',
        'DecimalParameters' => '',
        'DateTimeParameters' => ''
    ],
    'VersionDescription' => '',
    'DashboardPublishOptions' => [
        'AdHocFilteringOption' => '',
        'ExportToCSVOption' => '',
        'SheetControlsOption' => '',
        'VisualPublishOptions' => '',
        'SheetLayoutElementMaximizationOption' => '',
        'VisualMenuOption' => '',
        'VisualAxisSortOption' => '',
        'ExportWithHiddenFieldsOption' => '',
        'DataPointDrillUpDownOption' => '',
        'DataPointMenuLabelOption' => '',
        'DataPointTooltipOption' => ''
    ],
    'ThemeArn' => '',
    'Definition' => [
        'DataSetIdentifierDeclarations' => '',
        'Sheets' => '',
        'CalculatedFields' => '',
        'ParameterDeclarations' => '',
        'FilterGroups' => '',
        'ColumnConfigurations' => '',
        'AnalysisDefaults' => [
                'DefaultNewSheetConfiguration' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId', [
  'body' => '{
  "Name": "",
  "SourceEntity": {
    "SourceTemplate": ""
  },
  "Parameters": {
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  },
  "VersionDescription": "",
  "DashboardPublishOptions": {
    "AdHocFilteringOption": "",
    "ExportToCSVOption": "",
    "SheetControlsOption": "",
    "VisualPublishOptions": "",
    "SheetLayoutElementMaximizationOption": "",
    "VisualMenuOption": "",
    "VisualAxisSortOption": "",
    "ExportWithHiddenFieldsOption": "",
    "DataPointDrillUpDownOption": "",
    "DataPointMenuLabelOption": "",
    "DataPointTooltipOption": ""
  },
  "ThemeArn": "",
  "Definition": {
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'SourceEntity' => [
    'SourceTemplate' => ''
  ],
  'Parameters' => [
    'StringParameters' => '',
    'IntegerParameters' => '',
    'DecimalParameters' => '',
    'DateTimeParameters' => ''
  ],
  'VersionDescription' => '',
  'DashboardPublishOptions' => [
    'AdHocFilteringOption' => '',
    'ExportToCSVOption' => '',
    'SheetControlsOption' => '',
    'VisualPublishOptions' => '',
    'SheetLayoutElementMaximizationOption' => '',
    'VisualMenuOption' => '',
    'VisualAxisSortOption' => '',
    'ExportWithHiddenFieldsOption' => '',
    'DataPointDrillUpDownOption' => '',
    'DataPointMenuLabelOption' => '',
    'DataPointTooltipOption' => ''
  ],
  'ThemeArn' => '',
  'Definition' => [
    'DataSetIdentifierDeclarations' => '',
    'Sheets' => '',
    'CalculatedFields' => '',
    'ParameterDeclarations' => '',
    'FilterGroups' => '',
    'ColumnConfigurations' => '',
    'AnalysisDefaults' => [
        'DefaultNewSheetConfiguration' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => '',
  'SourceEntity' => [
    'SourceTemplate' => ''
  ],
  'Parameters' => [
    'StringParameters' => '',
    'IntegerParameters' => '',
    'DecimalParameters' => '',
    'DateTimeParameters' => ''
  ],
  'VersionDescription' => '',
  'DashboardPublishOptions' => [
    'AdHocFilteringOption' => '',
    'ExportToCSVOption' => '',
    'SheetControlsOption' => '',
    'VisualPublishOptions' => '',
    'SheetLayoutElementMaximizationOption' => '',
    'VisualMenuOption' => '',
    'VisualAxisSortOption' => '',
    'ExportWithHiddenFieldsOption' => '',
    'DataPointDrillUpDownOption' => '',
    'DataPointMenuLabelOption' => '',
    'DataPointTooltipOption' => ''
  ],
  'ThemeArn' => '',
  'Definition' => [
    'DataSetIdentifierDeclarations' => '',
    'Sheets' => '',
    'CalculatedFields' => '',
    'ParameterDeclarations' => '',
    'FilterGroups' => '',
    'ColumnConfigurations' => '',
    'AnalysisDefaults' => [
        'DefaultNewSheetConfiguration' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "SourceEntity": {
    "SourceTemplate": ""
  },
  "Parameters": {
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  },
  "VersionDescription": "",
  "DashboardPublishOptions": {
    "AdHocFilteringOption": "",
    "ExportToCSVOption": "",
    "SheetControlsOption": "",
    "VisualPublishOptions": "",
    "SheetLayoutElementMaximizationOption": "",
    "VisualMenuOption": "",
    "VisualAxisSortOption": "",
    "ExportWithHiddenFieldsOption": "",
    "DataPointDrillUpDownOption": "",
    "DataPointMenuLabelOption": "",
    "DataPointTooltipOption": ""
  },
  "ThemeArn": "",
  "Definition": {
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "SourceEntity": {
    "SourceTemplate": ""
  },
  "Parameters": {
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  },
  "VersionDescription": "",
  "DashboardPublishOptions": {
    "AdHocFilteringOption": "",
    "ExportToCSVOption": "",
    "SheetControlsOption": "",
    "VisualPublishOptions": "",
    "SheetLayoutElementMaximizationOption": "",
    "VisualMenuOption": "",
    "VisualAxisSortOption": "",
    "ExportWithHiddenFieldsOption": "",
    "DataPointDrillUpDownOption": "",
    "DataPointMenuLabelOption": "",
    "DataPointTooltipOption": ""
  },
  "ThemeArn": "",
  "Definition": {
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\",\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId"

payload = {
    "Name": "",
    "SourceEntity": { "SourceTemplate": "" },
    "Parameters": {
        "StringParameters": "",
        "IntegerParameters": "",
        "DecimalParameters": "",
        "DateTimeParameters": ""
    },
    "VersionDescription": "",
    "DashboardPublishOptions": {
        "AdHocFilteringOption": "",
        "ExportToCSVOption": "",
        "SheetControlsOption": "",
        "VisualPublishOptions": "",
        "SheetLayoutElementMaximizationOption": "",
        "VisualMenuOption": "",
        "VisualAxisSortOption": "",
        "ExportWithHiddenFieldsOption": "",
        "DataPointDrillUpDownOption": "",
        "DataPointMenuLabelOption": "",
        "DataPointTooltipOption": ""
    },
    "ThemeArn": "",
    "Definition": {
        "DataSetIdentifierDeclarations": "",
        "Sheets": "",
        "CalculatedFields": "",
        "ParameterDeclarations": "",
        "FilterGroups": "",
        "ColumnConfigurations": "",
        "AnalysisDefaults": { "DefaultNewSheetConfiguration": "" }
    }
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId"

payload <- "{\n  \"Name\": \"\",\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\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.put('/baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"SourceEntity\": {\n    \"SourceTemplate\": \"\"\n  },\n  \"Parameters\": {\n    \"StringParameters\": \"\",\n    \"IntegerParameters\": \"\",\n    \"DecimalParameters\": \"\",\n    \"DateTimeParameters\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"DashboardPublishOptions\": {\n    \"AdHocFilteringOption\": \"\",\n    \"ExportToCSVOption\": \"\",\n    \"SheetControlsOption\": \"\",\n    \"VisualPublishOptions\": \"\",\n    \"SheetLayoutElementMaximizationOption\": \"\",\n    \"VisualMenuOption\": \"\",\n    \"VisualAxisSortOption\": \"\",\n    \"ExportWithHiddenFieldsOption\": \"\",\n    \"DataPointDrillUpDownOption\": \"\",\n    \"DataPointMenuLabelOption\": \"\",\n    \"DataPointTooltipOption\": \"\"\n  },\n  \"ThemeArn\": \"\",\n  \"Definition\": {\n    \"DataSetIdentifierDeclarations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId";

    let payload = json!({
        "Name": "",
        "SourceEntity": json!({"SourceTemplate": ""}),
        "Parameters": json!({
            "StringParameters": "",
            "IntegerParameters": "",
            "DecimalParameters": "",
            "DateTimeParameters": ""
        }),
        "VersionDescription": "",
        "DashboardPublishOptions": json!({
            "AdHocFilteringOption": "",
            "ExportToCSVOption": "",
            "SheetControlsOption": "",
            "VisualPublishOptions": "",
            "SheetLayoutElementMaximizationOption": "",
            "VisualMenuOption": "",
            "VisualAxisSortOption": "",
            "ExportWithHiddenFieldsOption": "",
            "DataPointDrillUpDownOption": "",
            "DataPointMenuLabelOption": "",
            "DataPointTooltipOption": ""
        }),
        "ThemeArn": "",
        "Definition": json!({
            "DataSetIdentifierDeclarations": "",
            "Sheets": "",
            "CalculatedFields": "",
            "ParameterDeclarations": "",
            "FilterGroups": "",
            "ColumnConfigurations": "",
            "AnalysisDefaults": json!({"DefaultNewSheetConfiguration": ""})
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId \
  --header 'content-type: application/json' \
  --data '{
  "Name": "",
  "SourceEntity": {
    "SourceTemplate": ""
  },
  "Parameters": {
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  },
  "VersionDescription": "",
  "DashboardPublishOptions": {
    "AdHocFilteringOption": "",
    "ExportToCSVOption": "",
    "SheetControlsOption": "",
    "VisualPublishOptions": "",
    "SheetLayoutElementMaximizationOption": "",
    "VisualMenuOption": "",
    "VisualAxisSortOption": "",
    "ExportWithHiddenFieldsOption": "",
    "DataPointDrillUpDownOption": "",
    "DataPointMenuLabelOption": "",
    "DataPointTooltipOption": ""
  },
  "ThemeArn": "",
  "Definition": {
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}'

echo '{
  "Name": "",
  "SourceEntity": {
    "SourceTemplate": ""
  },
  "Parameters": {
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  },
  "VersionDescription": "",
  "DashboardPublishOptions": {
    "AdHocFilteringOption": "",
    "ExportToCSVOption": "",
    "SheetControlsOption": "",
    "VisualPublishOptions": "",
    "SheetLayoutElementMaximizationOption": "",
    "VisualMenuOption": "",
    "VisualAxisSortOption": "",
    "ExportWithHiddenFieldsOption": "",
    "DataPointDrillUpDownOption": "",
    "DataPointMenuLabelOption": "",
    "DataPointTooltipOption": ""
  },
  "ThemeArn": "",
  "Definition": {
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}' |  \
  http PUT {{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "SourceEntity": {\n    "SourceTemplate": ""\n  },\n  "Parameters": {\n    "StringParameters": "",\n    "IntegerParameters": "",\n    "DecimalParameters": "",\n    "DateTimeParameters": ""\n  },\n  "VersionDescription": "",\n  "DashboardPublishOptions": {\n    "AdHocFilteringOption": "",\n    "ExportToCSVOption": "",\n    "SheetControlsOption": "",\n    "VisualPublishOptions": "",\n    "SheetLayoutElementMaximizationOption": "",\n    "VisualMenuOption": "",\n    "VisualAxisSortOption": "",\n    "ExportWithHiddenFieldsOption": "",\n    "DataPointDrillUpDownOption": "",\n    "DataPointMenuLabelOption": "",\n    "DataPointTooltipOption": ""\n  },\n  "ThemeArn": "",\n  "Definition": {\n    "DataSetIdentifierDeclarations": "",\n    "Sheets": "",\n    "CalculatedFields": "",\n    "ParameterDeclarations": "",\n    "FilterGroups": "",\n    "ColumnConfigurations": "",\n    "AnalysisDefaults": {\n      "DefaultNewSheetConfiguration": ""\n    }\n  }\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "SourceEntity": ["SourceTemplate": ""],
  "Parameters": [
    "StringParameters": "",
    "IntegerParameters": "",
    "DecimalParameters": "",
    "DateTimeParameters": ""
  ],
  "VersionDescription": "",
  "DashboardPublishOptions": [
    "AdHocFilteringOption": "",
    "ExportToCSVOption": "",
    "SheetControlsOption": "",
    "VisualPublishOptions": "",
    "SheetLayoutElementMaximizationOption": "",
    "VisualMenuOption": "",
    "VisualAxisSortOption": "",
    "ExportWithHiddenFieldsOption": "",
    "DataPointDrillUpDownOption": "",
    "DataPointMenuLabelOption": "",
    "DataPointTooltipOption": ""
  ],
  "ThemeArn": "",
  "Definition": [
    "DataSetIdentifierDeclarations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": ["DefaultNewSheetConfiguration": ""]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

PUT UpdateDashboardPermissions

{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions

QUERY PARAMS

AwsAccountId

DashboardId

BODY json

{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ],
  "GrantLinkPermissions": [
    {}
  ],
  "RevokeLinkPermissions": [
    {}
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ],\n  \"GrantLinkPermissions\": [\n    {}\n  ],\n  \"RevokeLinkPermissions\": [\n    {}\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions" {:content-type :json
                                                                                                      :form-params {:GrantPermissions [{:Principal ""
                                                                                                                                        :Actions ""}]
                                                                                                                    :RevokePermissions [{}]
                                                                                                                    :GrantLinkPermissions [{}]
                                                                                                                    :RevokeLinkPermissions [{}]}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ],\n  \"GrantLinkPermissions\": [\n    {}\n  ],\n  \"RevokeLinkPermissions\": [\n    {}\n  ]\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions"),
    Content = new StringContent("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ],\n  \"GrantLinkPermissions\": [\n    {}\n  ],\n  \"RevokeLinkPermissions\": [\n    {}\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}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ],\n  \"GrantLinkPermissions\": [\n    {}\n  ],\n  \"RevokeLinkPermissions\": [\n    {}\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions"

	payload := strings.NewReader("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ],\n  \"GrantLinkPermissions\": [\n    {}\n  ],\n  \"RevokeLinkPermissions\": [\n    {}\n  ]\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	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))

}

PUT /baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId/permissions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 204

{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ],
  "GrantLinkPermissions": [
    {}
  ],
  "RevokeLinkPermissions": [
    {}
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ],\n  \"GrantLinkPermissions\": [\n    {}\n  ],\n  \"RevokeLinkPermissions\": [\n    {}\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ],\n  \"GrantLinkPermissions\": [\n    {}\n  ],\n  \"RevokeLinkPermissions\": [\n    {}\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  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ],\n  \"GrantLinkPermissions\": [\n    {}\n  ],\n  \"RevokeLinkPermissions\": [\n    {}\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions")
  .header("content-type", "application/json")
  .body("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ],\n  \"GrantLinkPermissions\": [\n    {}\n  ],\n  \"RevokeLinkPermissions\": [\n    {}\n  ]\n}")
  .asString();

const data = JSON.stringify({
  GrantPermissions: [
    {
      Principal: '',
      Actions: ''
    }
  ],
  RevokePermissions: [
    {}
  ],
  GrantLinkPermissions: [
    {}
  ],
  RevokeLinkPermissions: [
    {}
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions',
  headers: {'content-type': 'application/json'},
  data: {
    GrantPermissions: [{Principal: '', Actions: ''}],
    RevokePermissions: [{}],
    GrantLinkPermissions: [{}],
    RevokeLinkPermissions: [{}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"GrantPermissions":[{"Principal":"","Actions":""}],"RevokePermissions":[{}],"GrantLinkPermissions":[{}],"RevokeLinkPermissions":[{}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GrantPermissions": [\n    {\n      "Principal": "",\n      "Actions": ""\n    }\n  ],\n  "RevokePermissions": [\n    {}\n  ],\n  "GrantLinkPermissions": [\n    {}\n  ],\n  "RevokeLinkPermissions": [\n    {}\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  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ],\n  \"GrantLinkPermissions\": [\n    {}\n  ],\n  \"RevokeLinkPermissions\": [\n    {}\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId/permissions',
  headers: {
    '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({
  GrantPermissions: [{Principal: '', Actions: ''}],
  RevokePermissions: [{}],
  GrantLinkPermissions: [{}],
  RevokeLinkPermissions: [{}]
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions',
  headers: {'content-type': 'application/json'},
  body: {
    GrantPermissions: [{Principal: '', Actions: ''}],
    RevokePermissions: [{}],
    GrantLinkPermissions: [{}],
    RevokeLinkPermissions: [{}]
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GrantPermissions: [
    {
      Principal: '',
      Actions: ''
    }
  ],
  RevokePermissions: [
    {}
  ],
  GrantLinkPermissions: [
    {}
  ],
  RevokeLinkPermissions: [
    {}
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions',
  headers: {'content-type': 'application/json'},
  data: {
    GrantPermissions: [{Principal: '', Actions: ''}],
    RevokePermissions: [{}],
    GrantLinkPermissions: [{}],
    RevokeLinkPermissions: [{}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"GrantPermissions":[{"Principal":"","Actions":""}],"RevokePermissions":[{}],"GrantLinkPermissions":[{}],"RevokeLinkPermissions":[{}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GrantPermissions": @[ @{ @"Principal": @"", @"Actions": @"" } ],
                              @"RevokePermissions": @[ @{  } ],
                              @"GrantLinkPermissions": @[ @{  } ],
                              @"RevokeLinkPermissions": @[ @{  } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ],\n  \"GrantLinkPermissions\": [\n    {}\n  ],\n  \"RevokeLinkPermissions\": [\n    {}\n  ]\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'GrantPermissions' => [
        [
                'Principal' => '',
                'Actions' => ''
        ]
    ],
    'RevokePermissions' => [
        [
                
        ]
    ],
    'GrantLinkPermissions' => [
        [
                
        ]
    ],
    'RevokeLinkPermissions' => [
        [
                
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions', [
  'body' => '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ],
  "GrantLinkPermissions": [
    {}
  ],
  "RevokeLinkPermissions": [
    {}
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GrantPermissions' => [
    [
        'Principal' => '',
        'Actions' => ''
    ]
  ],
  'RevokePermissions' => [
    [
        
    ]
  ],
  'GrantLinkPermissions' => [
    [
        
    ]
  ],
  'RevokeLinkPermissions' => [
    [
        
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GrantPermissions' => [
    [
        'Principal' => '',
        'Actions' => ''
    ]
  ],
  'RevokePermissions' => [
    [
        
    ]
  ],
  'GrantLinkPermissions' => [
    [
        
    ]
  ],
  'RevokeLinkPermissions' => [
    [
        
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ],
  "GrantLinkPermissions": [
    {}
  ],
  "RevokeLinkPermissions": [
    {}
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ],
  "GrantLinkPermissions": [
    {}
  ],
  "RevokeLinkPermissions": [
    {}
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ],\n  \"GrantLinkPermissions\": [\n    {}\n  ],\n  \"RevokeLinkPermissions\": [\n    {}\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId/permissions", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions"

payload = {
    "GrantPermissions": [
        {
            "Principal": "",
            "Actions": ""
        }
    ],
    "RevokePermissions": [{}],
    "GrantLinkPermissions": [{}],
    "RevokeLinkPermissions": [{}]
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions"

payload <- "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ],\n  \"GrantLinkPermissions\": [\n    {}\n  ],\n  \"RevokeLinkPermissions\": [\n    {}\n  ]\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ],\n  \"GrantLinkPermissions\": [\n    {}\n  ],\n  \"RevokeLinkPermissions\": [\n    {}\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.put('/baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId/permissions') do |req|
  req.body = "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ],\n  \"GrantLinkPermissions\": [\n    {}\n  ],\n  \"RevokeLinkPermissions\": [\n    {}\n  ]\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions";

    let payload = json!({
        "GrantPermissions": (
            json!({
                "Principal": "",
                "Actions": ""
            })
        ),
        "RevokePermissions": (json!({})),
        "GrantLinkPermissions": (json!({})),
        "RevokeLinkPermissions": (json!({}))
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions \
  --header 'content-type: application/json' \
  --data '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ],
  "GrantLinkPermissions": [
    {}
  ],
  "RevokeLinkPermissions": [
    {}
  ]
}'

echo '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ],
  "GrantLinkPermissions": [
    {}
  ],
  "RevokeLinkPermissions": [
    {}
  ]
}' |  \
  http PUT {{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "GrantPermissions": [\n    {\n      "Principal": "",\n      "Actions": ""\n    }\n  ],\n  "RevokePermissions": [\n    {}\n  ],\n  "GrantLinkPermissions": [\n    {}\n  ],\n  "RevokeLinkPermissions": [\n    {}\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "GrantPermissions": [
    [
      "Principal": "",
      "Actions": ""
    ]
  ],
  "RevokePermissions": [[]],
  "GrantLinkPermissions": [[]],
  "RevokeLinkPermissions": [[]]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/permissions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

PUT UpdateDashboardPublishedVersion

{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber

QUERY PARAMS

AwsAccountId

DashboardId

VersionNumber

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber")

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber"

response = HTTP::Client.put url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber"

	req, _ := http.NewRequest("PUT", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber"))
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber")
  .put(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber';
const options = {method: 'PUT'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber',
  method: 'PUT',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber")
  .put(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber';
const options = {method: 'PUT'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber" in

Client.call `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber');
$request->setMethod(HTTP_METH_PUT);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber' -Method PUT

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber' -Method PUT

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PUT", "/baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber"

response <- VERB("PUT", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber

http PUT {{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/dashboards/:DashboardId/versions/:VersionNumber")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT UpdateDataSet

{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId

QUERY PARAMS

AwsAccountId

DataSetId

BODY json

{
  "Name": "",
  "PhysicalTableMap": {},
  "LogicalTableMap": {},
  "ImportMode": "",
  "ColumnGroups": [
    {
      "GeoSpatialColumnGroup": ""
    }
  ],
  "FieldFolders": {},
  "RowLevelPermissionDataSet": {
    "Namespace": "",
    "Arn": "",
    "PermissionPolicy": "",
    "FormatVersion": "",
    "Status": ""
  },
  "RowLevelPermissionTagConfiguration": {
    "Status": "",
    "TagRules": "",
    "TagRuleConfigurations": ""
  },
  "ColumnLevelPermissionRules": [
    {
      "Principals": "",
      "ColumnNames": ""
    }
  ],
  "DataSetUsageConfiguration": {
    "DisableUseAsDirectQuerySource": "",
    "DisableUseAsImportedSource": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId");

struct curl_slist *headers = NULL;
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  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId" {:content-type :json
                                                                                       :form-params {:Name ""
                                                                                                     :PhysicalTableMap {}
                                                                                                     :LogicalTableMap {}
                                                                                                     :ImportMode ""
                                                                                                     :ColumnGroups [{:GeoSpatialColumnGroup ""}]
                                                                                                     :FieldFolders {}
                                                                                                     :RowLevelPermissionDataSet {:Namespace ""
                                                                                                                                 :Arn ""
                                                                                                                                 :PermissionPolicy ""
                                                                                                                                 :FormatVersion ""
                                                                                                                                 :Status ""}
                                                                                                     :RowLevelPermissionTagConfiguration {:Status ""
                                                                                                                                          :TagRules ""
                                                                                                                                          :TagRuleConfigurations ""}
                                                                                                     :ColumnLevelPermissionRules [{:Principals ""
                                                                                                                                   :ColumnNames ""}]
                                                                                                     :DataSetUsageConfiguration {:DisableUseAsDirectQuerySource ""
                                                                                                                                 :DisableUseAsImportedSource ""}}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\n  }\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\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}}/accounts/:AwsAccountId/data-sets/:DataSetId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\n  }\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	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))

}

PUT /baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 656

{
  "Name": "",
  "PhysicalTableMap": {},
  "LogicalTableMap": {},
  "ImportMode": "",
  "ColumnGroups": [
    {
      "GeoSpatialColumnGroup": ""
    }
  ],
  "FieldFolders": {},
  "RowLevelPermissionDataSet": {
    "Namespace": "",
    "Arn": "",
    "PermissionPolicy": "",
    "FormatVersion": "",
    "Status": ""
  },
  "RowLevelPermissionTagConfiguration": {
    "Status": "",
    "TagRules": "",
    "TagRuleConfigurations": ""
  },
  "ColumnLevelPermissionRules": [
    {
      "Principals": "",
      "ColumnNames": ""
    }
  ],
  "DataSetUsageConfiguration": {
    "DisableUseAsDirectQuerySource": "",
    "DisableUseAsImportedSource": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\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  \"Name\": \"\",\n  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  PhysicalTableMap: {},
  LogicalTableMap: {},
  ImportMode: '',
  ColumnGroups: [
    {
      GeoSpatialColumnGroup: ''
    }
  ],
  FieldFolders: {},
  RowLevelPermissionDataSet: {
    Namespace: '',
    Arn: '',
    PermissionPolicy: '',
    FormatVersion: '',
    Status: ''
  },
  RowLevelPermissionTagConfiguration: {
    Status: '',
    TagRules: '',
    TagRuleConfigurations: ''
  },
  ColumnLevelPermissionRules: [
    {
      Principals: '',
      ColumnNames: ''
    }
  ],
  DataSetUsageConfiguration: {
    DisableUseAsDirectQuerySource: '',
    DisableUseAsImportedSource: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    PhysicalTableMap: {},
    LogicalTableMap: {},
    ImportMode: '',
    ColumnGroups: [{GeoSpatialColumnGroup: ''}],
    FieldFolders: {},
    RowLevelPermissionDataSet: {Namespace: '', Arn: '', PermissionPolicy: '', FormatVersion: '', Status: ''},
    RowLevelPermissionTagConfiguration: {Status: '', TagRules: '', TagRuleConfigurations: ''},
    ColumnLevelPermissionRules: [{Principals: '', ColumnNames: ''}],
    DataSetUsageConfiguration: {DisableUseAsDirectQuerySource: '', DisableUseAsImportedSource: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","PhysicalTableMap":{},"LogicalTableMap":{},"ImportMode":"","ColumnGroups":[{"GeoSpatialColumnGroup":""}],"FieldFolders":{},"RowLevelPermissionDataSet":{"Namespace":"","Arn":"","PermissionPolicy":"","FormatVersion":"","Status":""},"RowLevelPermissionTagConfiguration":{"Status":"","TagRules":"","TagRuleConfigurations":""},"ColumnLevelPermissionRules":[{"Principals":"","ColumnNames":""}],"DataSetUsageConfiguration":{"DisableUseAsDirectQuerySource":"","DisableUseAsImportedSource":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "PhysicalTableMap": {},\n  "LogicalTableMap": {},\n  "ImportMode": "",\n  "ColumnGroups": [\n    {\n      "GeoSpatialColumnGroup": ""\n    }\n  ],\n  "FieldFolders": {},\n  "RowLevelPermissionDataSet": {\n    "Namespace": "",\n    "Arn": "",\n    "PermissionPolicy": "",\n    "FormatVersion": "",\n    "Status": ""\n  },\n  "RowLevelPermissionTagConfiguration": {\n    "Status": "",\n    "TagRules": "",\n    "TagRuleConfigurations": ""\n  },\n  "ColumnLevelPermissionRules": [\n    {\n      "Principals": "",\n      "ColumnNames": ""\n    }\n  ],\n  "DataSetUsageConfiguration": {\n    "DisableUseAsDirectQuerySource": "",\n    "DisableUseAsImportedSource": ""\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  \"Name\": \"\",\n  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId',
  headers: {
    '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: '',
  PhysicalTableMap: {},
  LogicalTableMap: {},
  ImportMode: '',
  ColumnGroups: [{GeoSpatialColumnGroup: ''}],
  FieldFolders: {},
  RowLevelPermissionDataSet: {Namespace: '', Arn: '', PermissionPolicy: '', FormatVersion: '', Status: ''},
  RowLevelPermissionTagConfiguration: {Status: '', TagRules: '', TagRuleConfigurations: ''},
  ColumnLevelPermissionRules: [{Principals: '', ColumnNames: ''}],
  DataSetUsageConfiguration: {DisableUseAsDirectQuerySource: '', DisableUseAsImportedSource: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId',
  headers: {'content-type': 'application/json'},
  body: {
    Name: '',
    PhysicalTableMap: {},
    LogicalTableMap: {},
    ImportMode: '',
    ColumnGroups: [{GeoSpatialColumnGroup: ''}],
    FieldFolders: {},
    RowLevelPermissionDataSet: {Namespace: '', Arn: '', PermissionPolicy: '', FormatVersion: '', Status: ''},
    RowLevelPermissionTagConfiguration: {Status: '', TagRules: '', TagRuleConfigurations: ''},
    ColumnLevelPermissionRules: [{Principals: '', ColumnNames: ''}],
    DataSetUsageConfiguration: {DisableUseAsDirectQuerySource: '', DisableUseAsImportedSource: ''}
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: '',
  PhysicalTableMap: {},
  LogicalTableMap: {},
  ImportMode: '',
  ColumnGroups: [
    {
      GeoSpatialColumnGroup: ''
    }
  ],
  FieldFolders: {},
  RowLevelPermissionDataSet: {
    Namespace: '',
    Arn: '',
    PermissionPolicy: '',
    FormatVersion: '',
    Status: ''
  },
  RowLevelPermissionTagConfiguration: {
    Status: '',
    TagRules: '',
    TagRuleConfigurations: ''
  },
  ColumnLevelPermissionRules: [
    {
      Principals: '',
      ColumnNames: ''
    }
  ],
  DataSetUsageConfiguration: {
    DisableUseAsDirectQuerySource: '',
    DisableUseAsImportedSource: ''
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    PhysicalTableMap: {},
    LogicalTableMap: {},
    ImportMode: '',
    ColumnGroups: [{GeoSpatialColumnGroup: ''}],
    FieldFolders: {},
    RowLevelPermissionDataSet: {Namespace: '', Arn: '', PermissionPolicy: '', FormatVersion: '', Status: ''},
    RowLevelPermissionTagConfiguration: {Status: '', TagRules: '', TagRuleConfigurations: ''},
    ColumnLevelPermissionRules: [{Principals: '', ColumnNames: ''}],
    DataSetUsageConfiguration: {DisableUseAsDirectQuerySource: '', DisableUseAsImportedSource: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","PhysicalTableMap":{},"LogicalTableMap":{},"ImportMode":"","ColumnGroups":[{"GeoSpatialColumnGroup":""}],"FieldFolders":{},"RowLevelPermissionDataSet":{"Namespace":"","Arn":"","PermissionPolicy":"","FormatVersion":"","Status":""},"RowLevelPermissionTagConfiguration":{"Status":"","TagRules":"","TagRuleConfigurations":""},"ColumnLevelPermissionRules":[{"Principals":"","ColumnNames":""}],"DataSetUsageConfiguration":{"DisableUseAsDirectQuerySource":"","DisableUseAsImportedSource":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"PhysicalTableMap": @{  },
                              @"LogicalTableMap": @{  },
                              @"ImportMode": @"",
                              @"ColumnGroups": @[ @{ @"GeoSpatialColumnGroup": @"" } ],
                              @"FieldFolders": @{  },
                              @"RowLevelPermissionDataSet": @{ @"Namespace": @"", @"Arn": @"", @"PermissionPolicy": @"", @"FormatVersion": @"", @"Status": @"" },
                              @"RowLevelPermissionTagConfiguration": @{ @"Status": @"", @"TagRules": @"", @"TagRuleConfigurations": @"" },
                              @"ColumnLevelPermissionRules": @[ @{ @"Principals": @"", @"ColumnNames": @"" } ],
                              @"DataSetUsageConfiguration": @{ @"DisableUseAsDirectQuerySource": @"", @"DisableUseAsImportedSource": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/accounts/:AwsAccountId/data-sets/:DataSetId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'PhysicalTableMap' => [
        
    ],
    'LogicalTableMap' => [
        
    ],
    'ImportMode' => '',
    'ColumnGroups' => [
        [
                'GeoSpatialColumnGroup' => ''
        ]
    ],
    'FieldFolders' => [
        
    ],
    'RowLevelPermissionDataSet' => [
        'Namespace' => '',
        'Arn' => '',
        'PermissionPolicy' => '',
        'FormatVersion' => '',
        'Status' => ''
    ],
    'RowLevelPermissionTagConfiguration' => [
        'Status' => '',
        'TagRules' => '',
        'TagRuleConfigurations' => ''
    ],
    'ColumnLevelPermissionRules' => [
        [
                'Principals' => '',
                'ColumnNames' => ''
        ]
    ],
    'DataSetUsageConfiguration' => [
        'DisableUseAsDirectQuerySource' => '',
        'DisableUseAsImportedSource' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId', [
  'body' => '{
  "Name": "",
  "PhysicalTableMap": {},
  "LogicalTableMap": {},
  "ImportMode": "",
  "ColumnGroups": [
    {
      "GeoSpatialColumnGroup": ""
    }
  ],
  "FieldFolders": {},
  "RowLevelPermissionDataSet": {
    "Namespace": "",
    "Arn": "",
    "PermissionPolicy": "",
    "FormatVersion": "",
    "Status": ""
  },
  "RowLevelPermissionTagConfiguration": {
    "Status": "",
    "TagRules": "",
    "TagRuleConfigurations": ""
  },
  "ColumnLevelPermissionRules": [
    {
      "Principals": "",
      "ColumnNames": ""
    }
  ],
  "DataSetUsageConfiguration": {
    "DisableUseAsDirectQuerySource": "",
    "DisableUseAsImportedSource": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'PhysicalTableMap' => [
    
  ],
  'LogicalTableMap' => [
    
  ],
  'ImportMode' => '',
  'ColumnGroups' => [
    [
        'GeoSpatialColumnGroup' => ''
    ]
  ],
  'FieldFolders' => [
    
  ],
  'RowLevelPermissionDataSet' => [
    'Namespace' => '',
    'Arn' => '',
    'PermissionPolicy' => '',
    'FormatVersion' => '',
    'Status' => ''
  ],
  'RowLevelPermissionTagConfiguration' => [
    'Status' => '',
    'TagRules' => '',
    'TagRuleConfigurations' => ''
  ],
  'ColumnLevelPermissionRules' => [
    [
        'Principals' => '',
        'ColumnNames' => ''
    ]
  ],
  'DataSetUsageConfiguration' => [
    'DisableUseAsDirectQuerySource' => '',
    'DisableUseAsImportedSource' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => '',
  'PhysicalTableMap' => [
    
  ],
  'LogicalTableMap' => [
    
  ],
  'ImportMode' => '',
  'ColumnGroups' => [
    [
        'GeoSpatialColumnGroup' => ''
    ]
  ],
  'FieldFolders' => [
    
  ],
  'RowLevelPermissionDataSet' => [
    'Namespace' => '',
    'Arn' => '',
    'PermissionPolicy' => '',
    'FormatVersion' => '',
    'Status' => ''
  ],
  'RowLevelPermissionTagConfiguration' => [
    'Status' => '',
    'TagRules' => '',
    'TagRuleConfigurations' => ''
  ],
  'ColumnLevelPermissionRules' => [
    [
        'Principals' => '',
        'ColumnNames' => ''
    ]
  ],
  'DataSetUsageConfiguration' => [
    'DisableUseAsDirectQuerySource' => '',
    'DisableUseAsImportedSource' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "PhysicalTableMap": {},
  "LogicalTableMap": {},
  "ImportMode": "",
  "ColumnGroups": [
    {
      "GeoSpatialColumnGroup": ""
    }
  ],
  "FieldFolders": {},
  "RowLevelPermissionDataSet": {
    "Namespace": "",
    "Arn": "",
    "PermissionPolicy": "",
    "FormatVersion": "",
    "Status": ""
  },
  "RowLevelPermissionTagConfiguration": {
    "Status": "",
    "TagRules": "",
    "TagRuleConfigurations": ""
  },
  "ColumnLevelPermissionRules": [
    {
      "Principals": "",
      "ColumnNames": ""
    }
  ],
  "DataSetUsageConfiguration": {
    "DisableUseAsDirectQuerySource": "",
    "DisableUseAsImportedSource": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "PhysicalTableMap": {},
  "LogicalTableMap": {},
  "ImportMode": "",
  "ColumnGroups": [
    {
      "GeoSpatialColumnGroup": ""
    }
  ],
  "FieldFolders": {},
  "RowLevelPermissionDataSet": {
    "Namespace": "",
    "Arn": "",
    "PermissionPolicy": "",
    "FormatVersion": "",
    "Status": ""
  },
  "RowLevelPermissionTagConfiguration": {
    "Status": "",
    "TagRules": "",
    "TagRuleConfigurations": ""
  },
  "ColumnLevelPermissionRules": [
    {
      "Principals": "",
      "ColumnNames": ""
    }
  ],
  "DataSetUsageConfiguration": {
    "DisableUseAsDirectQuerySource": "",
    "DisableUseAsImportedSource": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\",\n  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId"

payload = {
    "Name": "",
    "PhysicalTableMap": {},
    "LogicalTableMap": {},
    "ImportMode": "",
    "ColumnGroups": [{ "GeoSpatialColumnGroup": "" }],
    "FieldFolders": {},
    "RowLevelPermissionDataSet": {
        "Namespace": "",
        "Arn": "",
        "PermissionPolicy": "",
        "FormatVersion": "",
        "Status": ""
    },
    "RowLevelPermissionTagConfiguration": {
        "Status": "",
        "TagRules": "",
        "TagRuleConfigurations": ""
    },
    "ColumnLevelPermissionRules": [
        {
            "Principals": "",
            "ColumnNames": ""
        }
    ],
    "DataSetUsageConfiguration": {
        "DisableUseAsDirectQuerySource": "",
        "DisableUseAsImportedSource": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId"

payload <- "{\n  \"Name\": \"\",\n  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\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.put('/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"PhysicalTableMap\": {},\n  \"LogicalTableMap\": {},\n  \"ImportMode\": \"\",\n  \"ColumnGroups\": [\n    {\n      \"GeoSpatialColumnGroup\": \"\"\n    }\n  ],\n  \"FieldFolders\": {},\n  \"RowLevelPermissionDataSet\": {\n    \"Namespace\": \"\",\n    \"Arn\": \"\",\n    \"PermissionPolicy\": \"\",\n    \"FormatVersion\": \"\",\n    \"Status\": \"\"\n  },\n  \"RowLevelPermissionTagConfiguration\": {\n    \"Status\": \"\",\n    \"TagRules\": \"\",\n    \"TagRuleConfigurations\": \"\"\n  },\n  \"ColumnLevelPermissionRules\": [\n    {\n      \"Principals\": \"\",\n      \"ColumnNames\": \"\"\n    }\n  ],\n  \"DataSetUsageConfiguration\": {\n    \"DisableUseAsDirectQuerySource\": \"\",\n    \"DisableUseAsImportedSource\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId";

    let payload = json!({
        "Name": "",
        "PhysicalTableMap": json!({}),
        "LogicalTableMap": json!({}),
        "ImportMode": "",
        "ColumnGroups": (json!({"GeoSpatialColumnGroup": ""})),
        "FieldFolders": json!({}),
        "RowLevelPermissionDataSet": json!({
            "Namespace": "",
            "Arn": "",
            "PermissionPolicy": "",
            "FormatVersion": "",
            "Status": ""
        }),
        "RowLevelPermissionTagConfiguration": json!({
            "Status": "",
            "TagRules": "",
            "TagRuleConfigurations": ""
        }),
        "ColumnLevelPermissionRules": (
            json!({
                "Principals": "",
                "ColumnNames": ""
            })
        ),
        "DataSetUsageConfiguration": json!({
            "DisableUseAsDirectQuerySource": "",
            "DisableUseAsImportedSource": ""
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId \
  --header 'content-type: application/json' \
  --data '{
  "Name": "",
  "PhysicalTableMap": {},
  "LogicalTableMap": {},
  "ImportMode": "",
  "ColumnGroups": [
    {
      "GeoSpatialColumnGroup": ""
    }
  ],
  "FieldFolders": {},
  "RowLevelPermissionDataSet": {
    "Namespace": "",
    "Arn": "",
    "PermissionPolicy": "",
    "FormatVersion": "",
    "Status": ""
  },
  "RowLevelPermissionTagConfiguration": {
    "Status": "",
    "TagRules": "",
    "TagRuleConfigurations": ""
  },
  "ColumnLevelPermissionRules": [
    {
      "Principals": "",
      "ColumnNames": ""
    }
  ],
  "DataSetUsageConfiguration": {
    "DisableUseAsDirectQuerySource": "",
    "DisableUseAsImportedSource": ""
  }
}'

echo '{
  "Name": "",
  "PhysicalTableMap": {},
  "LogicalTableMap": {},
  "ImportMode": "",
  "ColumnGroups": [
    {
      "GeoSpatialColumnGroup": ""
    }
  ],
  "FieldFolders": {},
  "RowLevelPermissionDataSet": {
    "Namespace": "",
    "Arn": "",
    "PermissionPolicy": "",
    "FormatVersion": "",
    "Status": ""
  },
  "RowLevelPermissionTagConfiguration": {
    "Status": "",
    "TagRules": "",
    "TagRuleConfigurations": ""
  },
  "ColumnLevelPermissionRules": [
    {
      "Principals": "",
      "ColumnNames": ""
    }
  ],
  "DataSetUsageConfiguration": {
    "DisableUseAsDirectQuerySource": "",
    "DisableUseAsImportedSource": ""
  }
}' |  \
  http PUT {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "PhysicalTableMap": {},\n  "LogicalTableMap": {},\n  "ImportMode": "",\n  "ColumnGroups": [\n    {\n      "GeoSpatialColumnGroup": ""\n    }\n  ],\n  "FieldFolders": {},\n  "RowLevelPermissionDataSet": {\n    "Namespace": "",\n    "Arn": "",\n    "PermissionPolicy": "",\n    "FormatVersion": "",\n    "Status": ""\n  },\n  "RowLevelPermissionTagConfiguration": {\n    "Status": "",\n    "TagRules": "",\n    "TagRuleConfigurations": ""\n  },\n  "ColumnLevelPermissionRules": [\n    {\n      "Principals": "",\n      "ColumnNames": ""\n    }\n  ],\n  "DataSetUsageConfiguration": {\n    "DisableUseAsDirectQuerySource": "",\n    "DisableUseAsImportedSource": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "PhysicalTableMap": [],
  "LogicalTableMap": [],
  "ImportMode": "",
  "ColumnGroups": [["GeoSpatialColumnGroup": ""]],
  "FieldFolders": [],
  "RowLevelPermissionDataSet": [
    "Namespace": "",
    "Arn": "",
    "PermissionPolicy": "",
    "FormatVersion": "",
    "Status": ""
  ],
  "RowLevelPermissionTagConfiguration": [
    "Status": "",
    "TagRules": "",
    "TagRuleConfigurations": ""
  ],
  "ColumnLevelPermissionRules": [
    [
      "Principals": "",
      "ColumnNames": ""
    ]
  ],
  "DataSetUsageConfiguration": [
    "DisableUseAsDirectQuerySource": "",
    "DisableUseAsImportedSource": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateDataSetPermissions

{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions

QUERY PARAMS

AwsAccountId

DataSetId

BODY json

{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions" {:content-type :json
                                                                                                    :form-params {:GrantPermissions [{:Principal ""
                                                                                                                                      :Actions ""}]
                                                                                                                  :RevokePermissions [{}]}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\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}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions"),
    Content = new StringContent("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\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}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions"

	payload := strings.NewReader("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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/accounts/:AwsAccountId/data-sets/:DataSetId/permissions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 123

{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\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  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions")
  .header("content-type", "application/json")
  .body("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}")
  .asString();

const data = JSON.stringify({
  GrantPermissions: [
    {
      Principal: '',
      Actions: ''
    }
  ],
  RevokePermissions: [
    {}
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions',
  headers: {'content-type': 'application/json'},
  data: {GrantPermissions: [{Principal: '', Actions: ''}], RevokePermissions: [{}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"GrantPermissions":[{"Principal":"","Actions":""}],"RevokePermissions":[{}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GrantPermissions": [\n    {\n      "Principal": "",\n      "Actions": ""\n    }\n  ],\n  "RevokePermissions": [\n    {}\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  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions")
  .post(body)
  .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/accounts/:AwsAccountId/data-sets/:DataSetId/permissions',
  headers: {
    '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({GrantPermissions: [{Principal: '', Actions: ''}], RevokePermissions: [{}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions',
  headers: {'content-type': 'application/json'},
  body: {GrantPermissions: [{Principal: '', Actions: ''}], RevokePermissions: [{}]},
  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}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GrantPermissions: [
    {
      Principal: '',
      Actions: ''
    }
  ],
  RevokePermissions: [
    {}
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions',
  headers: {'content-type': 'application/json'},
  data: {GrantPermissions: [{Principal: '', Actions: ''}], RevokePermissions: [{}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"GrantPermissions":[{"Principal":"","Actions":""}],"RevokePermissions":[{}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GrantPermissions": @[ @{ @"Principal": @"", @"Actions": @"" } ],
                              @"RevokePermissions": @[ @{  } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions"]
                                                       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}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions",
  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([
    'GrantPermissions' => [
        [
                'Principal' => '',
                'Actions' => ''
        ]
    ],
    'RevokePermissions' => [
        [
                
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions', [
  'body' => '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GrantPermissions' => [
    [
        'Principal' => '',
        'Actions' => ''
    ]
  ],
  'RevokePermissions' => [
    [
        
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GrantPermissions' => [
    [
        'Principal' => '',
        'Actions' => ''
    ]
  ],
  'RevokePermissions' => [
    [
        
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/permissions", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions"

payload = {
    "GrantPermissions": [
        {
            "Principal": "",
            "Actions": ""
        }
    ],
    "RevokePermissions": [{}]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions"

payload <- "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\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/accounts/:AwsAccountId/data-sets/:DataSetId/permissions') do |req|
  req.body = "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions";

    let payload = json!({
        "GrantPermissions": (
            json!({
                "Principal": "",
                "Actions": ""
            })
        ),
        "RevokePermissions": (json!({}))
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions \
  --header 'content-type: application/json' \
  --data '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}'

echo '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}' |  \
  http POST {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "GrantPermissions": [\n    {\n      "Principal": "",\n      "Actions": ""\n    }\n  ],\n  "RevokePermissions": [\n    {}\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "GrantPermissions": [
    [
      "Principal": "",
      "Actions": ""
    ]
  ],
  "RevokePermissions": [[]]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/permissions")! 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()

PUT UpdateDataSource

{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId

QUERY PARAMS

AwsAccountId

DataSourceId

BODY json

{
  "Name": "",
  "DataSourceParameters": {
    "AmazonElasticsearchParameters": "",
    "AthenaParameters": "",
    "AuroraParameters": "",
    "AuroraPostgreSqlParameters": "",
    "AwsIotAnalyticsParameters": "",
    "JiraParameters": "",
    "MariaDbParameters": "",
    "MySqlParameters": "",
    "OracleParameters": "",
    "PostgreSqlParameters": "",
    "PrestoParameters": "",
    "RdsParameters": "",
    "RedshiftParameters": "",
    "S3Parameters": "",
    "ServiceNowParameters": "",
    "SnowflakeParameters": "",
    "SparkParameters": "",
    "SqlServerParameters": "",
    "TeradataParameters": "",
    "TwitterParameters": "",
    "AmazonOpenSearchParameters": "",
    "ExasolParameters": "",
    "DatabricksParameters": ""
  },
  "Credentials": {
    "CredentialPair": "",
    "CopySourceArn": "",
    "SecretArn": ""
  },
  "VpcConnectionProperties": {
    "VpcConnectionArn": ""
  },
  "SslProperties": {
    "DisableSsl": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId");

struct curl_slist *headers = NULL;
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  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId" {:content-type :json
                                                                                             :form-params {:Name ""
                                                                                                           :DataSourceParameters {:AmazonElasticsearchParameters ""
                                                                                                                                  :AthenaParameters ""
                                                                                                                                  :AuroraParameters ""
                                                                                                                                  :AuroraPostgreSqlParameters ""
                                                                                                                                  :AwsIotAnalyticsParameters ""
                                                                                                                                  :JiraParameters ""
                                                                                                                                  :MariaDbParameters ""
                                                                                                                                  :MySqlParameters ""
                                                                                                                                  :OracleParameters ""
                                                                                                                                  :PostgreSqlParameters ""
                                                                                                                                  :PrestoParameters ""
                                                                                                                                  :RdsParameters ""
                                                                                                                                  :RedshiftParameters ""
                                                                                                                                  :S3Parameters ""
                                                                                                                                  :ServiceNowParameters ""
                                                                                                                                  :SnowflakeParameters ""
                                                                                                                                  :SparkParameters ""
                                                                                                                                  :SqlServerParameters ""
                                                                                                                                  :TeradataParameters ""
                                                                                                                                  :TwitterParameters ""
                                                                                                                                  :AmazonOpenSearchParameters ""
                                                                                                                                  :ExasolParameters ""
                                                                                                                                  :DatabricksParameters ""}
                                                                                                           :Credentials {:CredentialPair ""
                                                                                                                         :CopySourceArn ""
                                                                                                                         :SecretArn ""}
                                                                                                           :VpcConnectionProperties {:VpcConnectionArn ""}
                                                                                                           :SslProperties {:DisableSsl ""}}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\n  }\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\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}}/accounts/:AwsAccountId/data-sources/:DataSourceId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\n  }\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	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))

}

PUT /baseUrl/accounts/:AwsAccountId/data-sources/:DataSourceId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 952

{
  "Name": "",
  "DataSourceParameters": {
    "AmazonElasticsearchParameters": "",
    "AthenaParameters": "",
    "AuroraParameters": "",
    "AuroraPostgreSqlParameters": "",
    "AwsIotAnalyticsParameters": "",
    "JiraParameters": "",
    "MariaDbParameters": "",
    "MySqlParameters": "",
    "OracleParameters": "",
    "PostgreSqlParameters": "",
    "PrestoParameters": "",
    "RdsParameters": "",
    "RedshiftParameters": "",
    "S3Parameters": "",
    "ServiceNowParameters": "",
    "SnowflakeParameters": "",
    "SparkParameters": "",
    "SqlServerParameters": "",
    "TeradataParameters": "",
    "TwitterParameters": "",
    "AmazonOpenSearchParameters": "",
    "ExasolParameters": "",
    "DatabricksParameters": ""
  },
  "Credentials": {
    "CredentialPair": "",
    "CopySourceArn": "",
    "SecretArn": ""
  },
  "VpcConnectionProperties": {
    "VpcConnectionArn": ""
  },
  "SslProperties": {
    "DisableSsl": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\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  \"Name\": \"\",\n  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  DataSourceParameters: {
    AmazonElasticsearchParameters: '',
    AthenaParameters: '',
    AuroraParameters: '',
    AuroraPostgreSqlParameters: '',
    AwsIotAnalyticsParameters: '',
    JiraParameters: '',
    MariaDbParameters: '',
    MySqlParameters: '',
    OracleParameters: '',
    PostgreSqlParameters: '',
    PrestoParameters: '',
    RdsParameters: '',
    RedshiftParameters: '',
    S3Parameters: '',
    ServiceNowParameters: '',
    SnowflakeParameters: '',
    SparkParameters: '',
    SqlServerParameters: '',
    TeradataParameters: '',
    TwitterParameters: '',
    AmazonOpenSearchParameters: '',
    ExasolParameters: '',
    DatabricksParameters: ''
  },
  Credentials: {
    CredentialPair: '',
    CopySourceArn: '',
    SecretArn: ''
  },
  VpcConnectionProperties: {
    VpcConnectionArn: ''
  },
  SslProperties: {
    DisableSsl: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    DataSourceParameters: {
      AmazonElasticsearchParameters: '',
      AthenaParameters: '',
      AuroraParameters: '',
      AuroraPostgreSqlParameters: '',
      AwsIotAnalyticsParameters: '',
      JiraParameters: '',
      MariaDbParameters: '',
      MySqlParameters: '',
      OracleParameters: '',
      PostgreSqlParameters: '',
      PrestoParameters: '',
      RdsParameters: '',
      RedshiftParameters: '',
      S3Parameters: '',
      ServiceNowParameters: '',
      SnowflakeParameters: '',
      SparkParameters: '',
      SqlServerParameters: '',
      TeradataParameters: '',
      TwitterParameters: '',
      AmazonOpenSearchParameters: '',
      ExasolParameters: '',
      DatabricksParameters: ''
    },
    Credentials: {CredentialPair: '', CopySourceArn: '', SecretArn: ''},
    VpcConnectionProperties: {VpcConnectionArn: ''},
    SslProperties: {DisableSsl: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","DataSourceParameters":{"AmazonElasticsearchParameters":"","AthenaParameters":"","AuroraParameters":"","AuroraPostgreSqlParameters":"","AwsIotAnalyticsParameters":"","JiraParameters":"","MariaDbParameters":"","MySqlParameters":"","OracleParameters":"","PostgreSqlParameters":"","PrestoParameters":"","RdsParameters":"","RedshiftParameters":"","S3Parameters":"","ServiceNowParameters":"","SnowflakeParameters":"","SparkParameters":"","SqlServerParameters":"","TeradataParameters":"","TwitterParameters":"","AmazonOpenSearchParameters":"","ExasolParameters":"","DatabricksParameters":""},"Credentials":{"CredentialPair":"","CopySourceArn":"","SecretArn":""},"VpcConnectionProperties":{"VpcConnectionArn":""},"SslProperties":{"DisableSsl":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "DataSourceParameters": {\n    "AmazonElasticsearchParameters": "",\n    "AthenaParameters": "",\n    "AuroraParameters": "",\n    "AuroraPostgreSqlParameters": "",\n    "AwsIotAnalyticsParameters": "",\n    "JiraParameters": "",\n    "MariaDbParameters": "",\n    "MySqlParameters": "",\n    "OracleParameters": "",\n    "PostgreSqlParameters": "",\n    "PrestoParameters": "",\n    "RdsParameters": "",\n    "RedshiftParameters": "",\n    "S3Parameters": "",\n    "ServiceNowParameters": "",\n    "SnowflakeParameters": "",\n    "SparkParameters": "",\n    "SqlServerParameters": "",\n    "TeradataParameters": "",\n    "TwitterParameters": "",\n    "AmazonOpenSearchParameters": "",\n    "ExasolParameters": "",\n    "DatabricksParameters": ""\n  },\n  "Credentials": {\n    "CredentialPair": "",\n    "CopySourceArn": "",\n    "SecretArn": ""\n  },\n  "VpcConnectionProperties": {\n    "VpcConnectionArn": ""\n  },\n  "SslProperties": {\n    "DisableSsl": ""\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  \"Name\": \"\",\n  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/data-sources/:DataSourceId',
  headers: {
    '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: '',
  DataSourceParameters: {
    AmazonElasticsearchParameters: '',
    AthenaParameters: '',
    AuroraParameters: '',
    AuroraPostgreSqlParameters: '',
    AwsIotAnalyticsParameters: '',
    JiraParameters: '',
    MariaDbParameters: '',
    MySqlParameters: '',
    OracleParameters: '',
    PostgreSqlParameters: '',
    PrestoParameters: '',
    RdsParameters: '',
    RedshiftParameters: '',
    S3Parameters: '',
    ServiceNowParameters: '',
    SnowflakeParameters: '',
    SparkParameters: '',
    SqlServerParameters: '',
    TeradataParameters: '',
    TwitterParameters: '',
    AmazonOpenSearchParameters: '',
    ExasolParameters: '',
    DatabricksParameters: ''
  },
  Credentials: {CredentialPair: '', CopySourceArn: '', SecretArn: ''},
  VpcConnectionProperties: {VpcConnectionArn: ''},
  SslProperties: {DisableSsl: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId',
  headers: {'content-type': 'application/json'},
  body: {
    Name: '',
    DataSourceParameters: {
      AmazonElasticsearchParameters: '',
      AthenaParameters: '',
      AuroraParameters: '',
      AuroraPostgreSqlParameters: '',
      AwsIotAnalyticsParameters: '',
      JiraParameters: '',
      MariaDbParameters: '',
      MySqlParameters: '',
      OracleParameters: '',
      PostgreSqlParameters: '',
      PrestoParameters: '',
      RdsParameters: '',
      RedshiftParameters: '',
      S3Parameters: '',
      ServiceNowParameters: '',
      SnowflakeParameters: '',
      SparkParameters: '',
      SqlServerParameters: '',
      TeradataParameters: '',
      TwitterParameters: '',
      AmazonOpenSearchParameters: '',
      ExasolParameters: '',
      DatabricksParameters: ''
    },
    Credentials: {CredentialPair: '', CopySourceArn: '', SecretArn: ''},
    VpcConnectionProperties: {VpcConnectionArn: ''},
    SslProperties: {DisableSsl: ''}
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: '',
  DataSourceParameters: {
    AmazonElasticsearchParameters: '',
    AthenaParameters: '',
    AuroraParameters: '',
    AuroraPostgreSqlParameters: '',
    AwsIotAnalyticsParameters: '',
    JiraParameters: '',
    MariaDbParameters: '',
    MySqlParameters: '',
    OracleParameters: '',
    PostgreSqlParameters: '',
    PrestoParameters: '',
    RdsParameters: '',
    RedshiftParameters: '',
    S3Parameters: '',
    ServiceNowParameters: '',
    SnowflakeParameters: '',
    SparkParameters: '',
    SqlServerParameters: '',
    TeradataParameters: '',
    TwitterParameters: '',
    AmazonOpenSearchParameters: '',
    ExasolParameters: '',
    DatabricksParameters: ''
  },
  Credentials: {
    CredentialPair: '',
    CopySourceArn: '',
    SecretArn: ''
  },
  VpcConnectionProperties: {
    VpcConnectionArn: ''
  },
  SslProperties: {
    DisableSsl: ''
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    DataSourceParameters: {
      AmazonElasticsearchParameters: '',
      AthenaParameters: '',
      AuroraParameters: '',
      AuroraPostgreSqlParameters: '',
      AwsIotAnalyticsParameters: '',
      JiraParameters: '',
      MariaDbParameters: '',
      MySqlParameters: '',
      OracleParameters: '',
      PostgreSqlParameters: '',
      PrestoParameters: '',
      RdsParameters: '',
      RedshiftParameters: '',
      S3Parameters: '',
      ServiceNowParameters: '',
      SnowflakeParameters: '',
      SparkParameters: '',
      SqlServerParameters: '',
      TeradataParameters: '',
      TwitterParameters: '',
      AmazonOpenSearchParameters: '',
      ExasolParameters: '',
      DatabricksParameters: ''
    },
    Credentials: {CredentialPair: '', CopySourceArn: '', SecretArn: ''},
    VpcConnectionProperties: {VpcConnectionArn: ''},
    SslProperties: {DisableSsl: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","DataSourceParameters":{"AmazonElasticsearchParameters":"","AthenaParameters":"","AuroraParameters":"","AuroraPostgreSqlParameters":"","AwsIotAnalyticsParameters":"","JiraParameters":"","MariaDbParameters":"","MySqlParameters":"","OracleParameters":"","PostgreSqlParameters":"","PrestoParameters":"","RdsParameters":"","RedshiftParameters":"","S3Parameters":"","ServiceNowParameters":"","SnowflakeParameters":"","SparkParameters":"","SqlServerParameters":"","TeradataParameters":"","TwitterParameters":"","AmazonOpenSearchParameters":"","ExasolParameters":"","DatabricksParameters":""},"Credentials":{"CredentialPair":"","CopySourceArn":"","SecretArn":""},"VpcConnectionProperties":{"VpcConnectionArn":""},"SslProperties":{"DisableSsl":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"DataSourceParameters": @{ @"AmazonElasticsearchParameters": @"", @"AthenaParameters": @"", @"AuroraParameters": @"", @"AuroraPostgreSqlParameters": @"", @"AwsIotAnalyticsParameters": @"", @"JiraParameters": @"", @"MariaDbParameters": @"", @"MySqlParameters": @"", @"OracleParameters": @"", @"PostgreSqlParameters": @"", @"PrestoParameters": @"", @"RdsParameters": @"", @"RedshiftParameters": @"", @"S3Parameters": @"", @"ServiceNowParameters": @"", @"SnowflakeParameters": @"", @"SparkParameters": @"", @"SqlServerParameters": @"", @"TeradataParameters": @"", @"TwitterParameters": @"", @"AmazonOpenSearchParameters": @"", @"ExasolParameters": @"", @"DatabricksParameters": @"" },
                              @"Credentials": @{ @"CredentialPair": @"", @"CopySourceArn": @"", @"SecretArn": @"" },
                              @"VpcConnectionProperties": @{ @"VpcConnectionArn": @"" },
                              @"SslProperties": @{ @"DisableSsl": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/accounts/:AwsAccountId/data-sources/:DataSourceId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'DataSourceParameters' => [
        'AmazonElasticsearchParameters' => '',
        'AthenaParameters' => '',
        'AuroraParameters' => '',
        'AuroraPostgreSqlParameters' => '',
        'AwsIotAnalyticsParameters' => '',
        'JiraParameters' => '',
        'MariaDbParameters' => '',
        'MySqlParameters' => '',
        'OracleParameters' => '',
        'PostgreSqlParameters' => '',
        'PrestoParameters' => '',
        'RdsParameters' => '',
        'RedshiftParameters' => '',
        'S3Parameters' => '',
        'ServiceNowParameters' => '',
        'SnowflakeParameters' => '',
        'SparkParameters' => '',
        'SqlServerParameters' => '',
        'TeradataParameters' => '',
        'TwitterParameters' => '',
        'AmazonOpenSearchParameters' => '',
        'ExasolParameters' => '',
        'DatabricksParameters' => ''
    ],
    'Credentials' => [
        'CredentialPair' => '',
        'CopySourceArn' => '',
        'SecretArn' => ''
    ],
    'VpcConnectionProperties' => [
        'VpcConnectionArn' => ''
    ],
    'SslProperties' => [
        'DisableSsl' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId', [
  'body' => '{
  "Name": "",
  "DataSourceParameters": {
    "AmazonElasticsearchParameters": "",
    "AthenaParameters": "",
    "AuroraParameters": "",
    "AuroraPostgreSqlParameters": "",
    "AwsIotAnalyticsParameters": "",
    "JiraParameters": "",
    "MariaDbParameters": "",
    "MySqlParameters": "",
    "OracleParameters": "",
    "PostgreSqlParameters": "",
    "PrestoParameters": "",
    "RdsParameters": "",
    "RedshiftParameters": "",
    "S3Parameters": "",
    "ServiceNowParameters": "",
    "SnowflakeParameters": "",
    "SparkParameters": "",
    "SqlServerParameters": "",
    "TeradataParameters": "",
    "TwitterParameters": "",
    "AmazonOpenSearchParameters": "",
    "ExasolParameters": "",
    "DatabricksParameters": ""
  },
  "Credentials": {
    "CredentialPair": "",
    "CopySourceArn": "",
    "SecretArn": ""
  },
  "VpcConnectionProperties": {
    "VpcConnectionArn": ""
  },
  "SslProperties": {
    "DisableSsl": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'DataSourceParameters' => [
    'AmazonElasticsearchParameters' => '',
    'AthenaParameters' => '',
    'AuroraParameters' => '',
    'AuroraPostgreSqlParameters' => '',
    'AwsIotAnalyticsParameters' => '',
    'JiraParameters' => '',
    'MariaDbParameters' => '',
    'MySqlParameters' => '',
    'OracleParameters' => '',
    'PostgreSqlParameters' => '',
    'PrestoParameters' => '',
    'RdsParameters' => '',
    'RedshiftParameters' => '',
    'S3Parameters' => '',
    'ServiceNowParameters' => '',
    'SnowflakeParameters' => '',
    'SparkParameters' => '',
    'SqlServerParameters' => '',
    'TeradataParameters' => '',
    'TwitterParameters' => '',
    'AmazonOpenSearchParameters' => '',
    'ExasolParameters' => '',
    'DatabricksParameters' => ''
  ],
  'Credentials' => [
    'CredentialPair' => '',
    'CopySourceArn' => '',
    'SecretArn' => ''
  ],
  'VpcConnectionProperties' => [
    'VpcConnectionArn' => ''
  ],
  'SslProperties' => [
    'DisableSsl' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => '',
  'DataSourceParameters' => [
    'AmazonElasticsearchParameters' => '',
    'AthenaParameters' => '',
    'AuroraParameters' => '',
    'AuroraPostgreSqlParameters' => '',
    'AwsIotAnalyticsParameters' => '',
    'JiraParameters' => '',
    'MariaDbParameters' => '',
    'MySqlParameters' => '',
    'OracleParameters' => '',
    'PostgreSqlParameters' => '',
    'PrestoParameters' => '',
    'RdsParameters' => '',
    'RedshiftParameters' => '',
    'S3Parameters' => '',
    'ServiceNowParameters' => '',
    'SnowflakeParameters' => '',
    'SparkParameters' => '',
    'SqlServerParameters' => '',
    'TeradataParameters' => '',
    'TwitterParameters' => '',
    'AmazonOpenSearchParameters' => '',
    'ExasolParameters' => '',
    'DatabricksParameters' => ''
  ],
  'Credentials' => [
    'CredentialPair' => '',
    'CopySourceArn' => '',
    'SecretArn' => ''
  ],
  'VpcConnectionProperties' => [
    'VpcConnectionArn' => ''
  ],
  'SslProperties' => [
    'DisableSsl' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "DataSourceParameters": {
    "AmazonElasticsearchParameters": "",
    "AthenaParameters": "",
    "AuroraParameters": "",
    "AuroraPostgreSqlParameters": "",
    "AwsIotAnalyticsParameters": "",
    "JiraParameters": "",
    "MariaDbParameters": "",
    "MySqlParameters": "",
    "OracleParameters": "",
    "PostgreSqlParameters": "",
    "PrestoParameters": "",
    "RdsParameters": "",
    "RedshiftParameters": "",
    "S3Parameters": "",
    "ServiceNowParameters": "",
    "SnowflakeParameters": "",
    "SparkParameters": "",
    "SqlServerParameters": "",
    "TeradataParameters": "",
    "TwitterParameters": "",
    "AmazonOpenSearchParameters": "",
    "ExasolParameters": "",
    "DatabricksParameters": ""
  },
  "Credentials": {
    "CredentialPair": "",
    "CopySourceArn": "",
    "SecretArn": ""
  },
  "VpcConnectionProperties": {
    "VpcConnectionArn": ""
  },
  "SslProperties": {
    "DisableSsl": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "DataSourceParameters": {
    "AmazonElasticsearchParameters": "",
    "AthenaParameters": "",
    "AuroraParameters": "",
    "AuroraPostgreSqlParameters": "",
    "AwsIotAnalyticsParameters": "",
    "JiraParameters": "",
    "MariaDbParameters": "",
    "MySqlParameters": "",
    "OracleParameters": "",
    "PostgreSqlParameters": "",
    "PrestoParameters": "",
    "RdsParameters": "",
    "RedshiftParameters": "",
    "S3Parameters": "",
    "ServiceNowParameters": "",
    "SnowflakeParameters": "",
    "SparkParameters": "",
    "SqlServerParameters": "",
    "TeradataParameters": "",
    "TwitterParameters": "",
    "AmazonOpenSearchParameters": "",
    "ExasolParameters": "",
    "DatabricksParameters": ""
  },
  "Credentials": {
    "CredentialPair": "",
    "CopySourceArn": "",
    "SecretArn": ""
  },
  "VpcConnectionProperties": {
    "VpcConnectionArn": ""
  },
  "SslProperties": {
    "DisableSsl": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\",\n  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/accounts/:AwsAccountId/data-sources/:DataSourceId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId"

payload = {
    "Name": "",
    "DataSourceParameters": {
        "AmazonElasticsearchParameters": "",
        "AthenaParameters": "",
        "AuroraParameters": "",
        "AuroraPostgreSqlParameters": "",
        "AwsIotAnalyticsParameters": "",
        "JiraParameters": "",
        "MariaDbParameters": "",
        "MySqlParameters": "",
        "OracleParameters": "",
        "PostgreSqlParameters": "",
        "PrestoParameters": "",
        "RdsParameters": "",
        "RedshiftParameters": "",
        "S3Parameters": "",
        "ServiceNowParameters": "",
        "SnowflakeParameters": "",
        "SparkParameters": "",
        "SqlServerParameters": "",
        "TeradataParameters": "",
        "TwitterParameters": "",
        "AmazonOpenSearchParameters": "",
        "ExasolParameters": "",
        "DatabricksParameters": ""
    },
    "Credentials": {
        "CredentialPair": "",
        "CopySourceArn": "",
        "SecretArn": ""
    },
    "VpcConnectionProperties": { "VpcConnectionArn": "" },
    "SslProperties": { "DisableSsl": "" }
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId"

payload <- "{\n  \"Name\": \"\",\n  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\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.put('/baseUrl/accounts/:AwsAccountId/data-sources/:DataSourceId') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"DataSourceParameters\": {\n    \"AmazonElasticsearchParameters\": \"\",\n    \"AthenaParameters\": \"\",\n    \"AuroraParameters\": \"\",\n    \"AuroraPostgreSqlParameters\": \"\",\n    \"AwsIotAnalyticsParameters\": \"\",\n    \"JiraParameters\": \"\",\n    \"MariaDbParameters\": \"\",\n    \"MySqlParameters\": \"\",\n    \"OracleParameters\": \"\",\n    \"PostgreSqlParameters\": \"\",\n    \"PrestoParameters\": \"\",\n    \"RdsParameters\": \"\",\n    \"RedshiftParameters\": \"\",\n    \"S3Parameters\": \"\",\n    \"ServiceNowParameters\": \"\",\n    \"SnowflakeParameters\": \"\",\n    \"SparkParameters\": \"\",\n    \"SqlServerParameters\": \"\",\n    \"TeradataParameters\": \"\",\n    \"TwitterParameters\": \"\",\n    \"AmazonOpenSearchParameters\": \"\",\n    \"ExasolParameters\": \"\",\n    \"DatabricksParameters\": \"\"\n  },\n  \"Credentials\": {\n    \"CredentialPair\": \"\",\n    \"CopySourceArn\": \"\",\n    \"SecretArn\": \"\"\n  },\n  \"VpcConnectionProperties\": {\n    \"VpcConnectionArn\": \"\"\n  },\n  \"SslProperties\": {\n    \"DisableSsl\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId";

    let payload = json!({
        "Name": "",
        "DataSourceParameters": json!({
            "AmazonElasticsearchParameters": "",
            "AthenaParameters": "",
            "AuroraParameters": "",
            "AuroraPostgreSqlParameters": "",
            "AwsIotAnalyticsParameters": "",
            "JiraParameters": "",
            "MariaDbParameters": "",
            "MySqlParameters": "",
            "OracleParameters": "",
            "PostgreSqlParameters": "",
            "PrestoParameters": "",
            "RdsParameters": "",
            "RedshiftParameters": "",
            "S3Parameters": "",
            "ServiceNowParameters": "",
            "SnowflakeParameters": "",
            "SparkParameters": "",
            "SqlServerParameters": "",
            "TeradataParameters": "",
            "TwitterParameters": "",
            "AmazonOpenSearchParameters": "",
            "ExasolParameters": "",
            "DatabricksParameters": ""
        }),
        "Credentials": json!({
            "CredentialPair": "",
            "CopySourceArn": "",
            "SecretArn": ""
        }),
        "VpcConnectionProperties": json!({"VpcConnectionArn": ""}),
        "SslProperties": json!({"DisableSsl": ""})
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId \
  --header 'content-type: application/json' \
  --data '{
  "Name": "",
  "DataSourceParameters": {
    "AmazonElasticsearchParameters": "",
    "AthenaParameters": "",
    "AuroraParameters": "",
    "AuroraPostgreSqlParameters": "",
    "AwsIotAnalyticsParameters": "",
    "JiraParameters": "",
    "MariaDbParameters": "",
    "MySqlParameters": "",
    "OracleParameters": "",
    "PostgreSqlParameters": "",
    "PrestoParameters": "",
    "RdsParameters": "",
    "RedshiftParameters": "",
    "S3Parameters": "",
    "ServiceNowParameters": "",
    "SnowflakeParameters": "",
    "SparkParameters": "",
    "SqlServerParameters": "",
    "TeradataParameters": "",
    "TwitterParameters": "",
    "AmazonOpenSearchParameters": "",
    "ExasolParameters": "",
    "DatabricksParameters": ""
  },
  "Credentials": {
    "CredentialPair": "",
    "CopySourceArn": "",
    "SecretArn": ""
  },
  "VpcConnectionProperties": {
    "VpcConnectionArn": ""
  },
  "SslProperties": {
    "DisableSsl": ""
  }
}'

echo '{
  "Name": "",
  "DataSourceParameters": {
    "AmazonElasticsearchParameters": "",
    "AthenaParameters": "",
    "AuroraParameters": "",
    "AuroraPostgreSqlParameters": "",
    "AwsIotAnalyticsParameters": "",
    "JiraParameters": "",
    "MariaDbParameters": "",
    "MySqlParameters": "",
    "OracleParameters": "",
    "PostgreSqlParameters": "",
    "PrestoParameters": "",
    "RdsParameters": "",
    "RedshiftParameters": "",
    "S3Parameters": "",
    "ServiceNowParameters": "",
    "SnowflakeParameters": "",
    "SparkParameters": "",
    "SqlServerParameters": "",
    "TeradataParameters": "",
    "TwitterParameters": "",
    "AmazonOpenSearchParameters": "",
    "ExasolParameters": "",
    "DatabricksParameters": ""
  },
  "Credentials": {
    "CredentialPair": "",
    "CopySourceArn": "",
    "SecretArn": ""
  },
  "VpcConnectionProperties": {
    "VpcConnectionArn": ""
  },
  "SslProperties": {
    "DisableSsl": ""
  }
}' |  \
  http PUT {{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "DataSourceParameters": {\n    "AmazonElasticsearchParameters": "",\n    "AthenaParameters": "",\n    "AuroraParameters": "",\n    "AuroraPostgreSqlParameters": "",\n    "AwsIotAnalyticsParameters": "",\n    "JiraParameters": "",\n    "MariaDbParameters": "",\n    "MySqlParameters": "",\n    "OracleParameters": "",\n    "PostgreSqlParameters": "",\n    "PrestoParameters": "",\n    "RdsParameters": "",\n    "RedshiftParameters": "",\n    "S3Parameters": "",\n    "ServiceNowParameters": "",\n    "SnowflakeParameters": "",\n    "SparkParameters": "",\n    "SqlServerParameters": "",\n    "TeradataParameters": "",\n    "TwitterParameters": "",\n    "AmazonOpenSearchParameters": "",\n    "ExasolParameters": "",\n    "DatabricksParameters": ""\n  },\n  "Credentials": {\n    "CredentialPair": "",\n    "CopySourceArn": "",\n    "SecretArn": ""\n  },\n  "VpcConnectionProperties": {\n    "VpcConnectionArn": ""\n  },\n  "SslProperties": {\n    "DisableSsl": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "DataSourceParameters": [
    "AmazonElasticsearchParameters": "",
    "AthenaParameters": "",
    "AuroraParameters": "",
    "AuroraPostgreSqlParameters": "",
    "AwsIotAnalyticsParameters": "",
    "JiraParameters": "",
    "MariaDbParameters": "",
    "MySqlParameters": "",
    "OracleParameters": "",
    "PostgreSqlParameters": "",
    "PrestoParameters": "",
    "RdsParameters": "",
    "RedshiftParameters": "",
    "S3Parameters": "",
    "ServiceNowParameters": "",
    "SnowflakeParameters": "",
    "SparkParameters": "",
    "SqlServerParameters": "",
    "TeradataParameters": "",
    "TwitterParameters": "",
    "AmazonOpenSearchParameters": "",
    "ExasolParameters": "",
    "DatabricksParameters": ""
  ],
  "Credentials": [
    "CredentialPair": "",
    "CopySourceArn": "",
    "SecretArn": ""
  ],
  "VpcConnectionProperties": ["VpcConnectionArn": ""],
  "SslProperties": ["DisableSsl": ""]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateDataSourcePermissions

{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions

QUERY PARAMS

AwsAccountId

DataSourceId

BODY json

{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions" {:content-type :json
                                                                                                          :form-params {:GrantPermissions [{:Principal ""
                                                                                                                                            :Actions ""}]
                                                                                                                        :RevokePermissions [{}]}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\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}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions"),
    Content = new StringContent("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\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}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions"

	payload := strings.NewReader("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 123

{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\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  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions")
  .header("content-type", "application/json")
  .body("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}")
  .asString();

const data = JSON.stringify({
  GrantPermissions: [
    {
      Principal: '',
      Actions: ''
    }
  ],
  RevokePermissions: [
    {}
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions',
  headers: {'content-type': 'application/json'},
  data: {GrantPermissions: [{Principal: '', Actions: ''}], RevokePermissions: [{}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"GrantPermissions":[{"Principal":"","Actions":""}],"RevokePermissions":[{}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GrantPermissions": [\n    {\n      "Principal": "",\n      "Actions": ""\n    }\n  ],\n  "RevokePermissions": [\n    {}\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  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions")
  .post(body)
  .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/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions',
  headers: {
    '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({GrantPermissions: [{Principal: '', Actions: ''}], RevokePermissions: [{}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions',
  headers: {'content-type': 'application/json'},
  body: {GrantPermissions: [{Principal: '', Actions: ''}], RevokePermissions: [{}]},
  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}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GrantPermissions: [
    {
      Principal: '',
      Actions: ''
    }
  ],
  RevokePermissions: [
    {}
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions',
  headers: {'content-type': 'application/json'},
  data: {GrantPermissions: [{Principal: '', Actions: ''}], RevokePermissions: [{}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"GrantPermissions":[{"Principal":"","Actions":""}],"RevokePermissions":[{}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GrantPermissions": @[ @{ @"Principal": @"", @"Actions": @"" } ],
                              @"RevokePermissions": @[ @{  } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions"]
                                                       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}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions",
  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([
    'GrantPermissions' => [
        [
                'Principal' => '',
                'Actions' => ''
        ]
    ],
    'RevokePermissions' => [
        [
                
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions', [
  'body' => '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GrantPermissions' => [
    [
        'Principal' => '',
        'Actions' => ''
    ]
  ],
  'RevokePermissions' => [
    [
        
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GrantPermissions' => [
    [
        'Principal' => '',
        'Actions' => ''
    ]
  ],
  'RevokePermissions' => [
    [
        
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions"

payload = {
    "GrantPermissions": [
        {
            "Principal": "",
            "Actions": ""
        }
    ],
    "RevokePermissions": [{}]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions"

payload <- "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\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/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions') do |req|
  req.body = "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions";

    let payload = json!({
        "GrantPermissions": (
            json!({
                "Principal": "",
                "Actions": ""
            })
        ),
        "RevokePermissions": (json!({}))
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions \
  --header 'content-type: application/json' \
  --data '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}'

echo '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}' |  \
  http POST {{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "GrantPermissions": [\n    {\n      "Principal": "",\n      "Actions": ""\n    }\n  ],\n  "RevokePermissions": [\n    {}\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "GrantPermissions": [
    [
      "Principal": "",
      "Actions": ""
    ]
  ],
  "RevokePermissions": [[]]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/data-sources/:DataSourceId/permissions")! 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()

PUT UpdateFolder

{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId

QUERY PARAMS

AwsAccountId

FolderId

BODY json

{
  "Name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId" {:content-type :json
                                                                                    :form-params {:Name ""}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId"),
    Content = new StringContent("{\n  \"Name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId"

	payload := strings.NewReader("{\n  \"Name\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	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))

}

PUT /baseUrl/accounts/:AwsAccountId/folders/:FolderId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "Name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId',
  headers: {'content-type': 'application/json'},
  data: {Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/folders/:FolderId',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId',
  headers: {'content-type': 'application/json'},
  body: {Name: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId',
  headers: {'content-type': 'application/json'},
  data: {Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/accounts/:AwsAccountId/folders/:FolderId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId', [
  'body' => '{
  "Name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/accounts/:AwsAccountId/folders/:FolderId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId"

payload = { "Name": "" }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId"

payload <- "{\n  \"Name\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/accounts/:AwsAccountId/folders/:FolderId') do |req|
  req.body = "{\n  \"Name\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId";

    let payload = json!({"Name": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId \
  --header 'content-type: application/json' \
  --data '{
  "Name": ""
}'

echo '{
  "Name": ""
}' |  \
  http PUT {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": ""\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["Name": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

PUT UpdateFolderPermissions

{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions

QUERY PARAMS

AwsAccountId

FolderId

BODY json

{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions" {:content-type :json
                                                                                                :form-params {:GrantPermissions [{:Principal ""
                                                                                                                                  :Actions ""}]
                                                                                                              :RevokePermissions [{}]}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions"),
    Content = new StringContent("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\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}}/accounts/:AwsAccountId/folders/:FolderId/permissions");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions"

	payload := strings.NewReader("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	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))

}

PUT /baseUrl/accounts/:AwsAccountId/folders/:FolderId/permissions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 123

{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\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  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions")
  .header("content-type", "application/json")
  .body("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}")
  .asString();

const data = JSON.stringify({
  GrantPermissions: [
    {
      Principal: '',
      Actions: ''
    }
  ],
  RevokePermissions: [
    {}
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions',
  headers: {'content-type': 'application/json'},
  data: {GrantPermissions: [{Principal: '', Actions: ''}], RevokePermissions: [{}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"GrantPermissions":[{"Principal":"","Actions":""}],"RevokePermissions":[{}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GrantPermissions": [\n    {\n      "Principal": "",\n      "Actions": ""\n    }\n  ],\n  "RevokePermissions": [\n    {}\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  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/folders/:FolderId/permissions',
  headers: {
    '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({GrantPermissions: [{Principal: '', Actions: ''}], RevokePermissions: [{}]}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions',
  headers: {'content-type': 'application/json'},
  body: {GrantPermissions: [{Principal: '', Actions: ''}], RevokePermissions: [{}]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GrantPermissions: [
    {
      Principal: '',
      Actions: ''
    }
  ],
  RevokePermissions: [
    {}
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions',
  headers: {'content-type': 'application/json'},
  data: {GrantPermissions: [{Principal: '', Actions: ''}], RevokePermissions: [{}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"GrantPermissions":[{"Principal":"","Actions":""}],"RevokePermissions":[{}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GrantPermissions": @[ @{ @"Principal": @"", @"Actions": @"" } ],
                              @"RevokePermissions": @[ @{  } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/accounts/:AwsAccountId/folders/:FolderId/permissions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'GrantPermissions' => [
        [
                'Principal' => '',
                'Actions' => ''
        ]
    ],
    'RevokePermissions' => [
        [
                
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions', [
  'body' => '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GrantPermissions' => [
    [
        'Principal' => '',
        'Actions' => ''
    ]
  ],
  'RevokePermissions' => [
    [
        
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GrantPermissions' => [
    [
        'Principal' => '',
        'Actions' => ''
    ]
  ],
  'RevokePermissions' => [
    [
        
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/accounts/:AwsAccountId/folders/:FolderId/permissions", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions"

payload = {
    "GrantPermissions": [
        {
            "Principal": "",
            "Actions": ""
        }
    ],
    "RevokePermissions": [{}]
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions"

payload <- "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\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.put('/baseUrl/accounts/:AwsAccountId/folders/:FolderId/permissions') do |req|
  req.body = "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions";

    let payload = json!({
        "GrantPermissions": (
            json!({
                "Principal": "",
                "Actions": ""
            })
        ),
        "RevokePermissions": (json!({}))
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions \
  --header 'content-type: application/json' \
  --data '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}'

echo '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}' |  \
  http PUT {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "GrantPermissions": [\n    {\n      "Principal": "",\n      "Actions": ""\n    }\n  ],\n  "RevokePermissions": [\n    {}\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "GrantPermissions": [
    [
      "Principal": "",
      "Actions": ""
    ]
  ],
  "RevokePermissions": [[]]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/folders/:FolderId/permissions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

PUT UpdateGroup

{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName

QUERY PARAMS

GroupName

AwsAccountId

Namespace

BODY json

{
  "Description": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName");

struct curl_slist *headers = NULL;
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}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName" {:content-type :json
                                                                                                          :form-params {:Description ""}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Description\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName"),
    Content = new StringContent("{\n  \"Description\": \"\"\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}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Description\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName"

	payload := strings.NewReader("{\n  \"Description\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	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))

}

PUT /baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 23

{
  "Description": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Description\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"Description\": \"\"\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}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName")
  .header("content-type", "application/json")
  .body("{\n  \"Description\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Description: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName',
  headers: {'content-type': 'application/json'},
  data: {Description: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Description":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Description": ""\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}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName',
  headers: {
    '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: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName',
  headers: {'content-type': 'application/json'},
  body: {Description: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Description: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName',
  headers: {'content-type': 'application/json'},
  data: {Description: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Description":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Description": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Description\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'Description' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName', [
  'body' => '{
  "Description": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Description' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Description' => ''
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Description": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Description": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Description\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName"

payload = { "Description": "" }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName"

payload <- "{\n  \"Description\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Description\": \"\"\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.put('/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName') do |req|
  req.body = "{\n  \"Description\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName";

    let payload = json!({"Description": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName \
  --header 'content-type: application/json' \
  --data '{
  "Description": ""
}'

echo '{
  "Description": ""
}' |  \
  http PUT {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "Description": ""\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["Description": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/groups/:GroupName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

PUT UpdateIAMPolicyAssignment

{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName

QUERY PARAMS

AwsAccountId

AssignmentName

Namespace

BODY json

{
  "AssignmentStatus": "",
  "PolicyArn": "",
  "Identities": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName" {:content-type :json
                                                                                                                               :form-params {:AssignmentStatus ""
                                                                                                                                             :PolicyArn ""
                                                                                                                                             :Identities {}}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName"),
    Content = new StringContent("{\n  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\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}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName"

	payload := strings.NewReader("{\n  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	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))

}

PUT /baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 67

{
  "AssignmentStatus": "",
  "PolicyArn": "",
  "Identities": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\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  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName")
  .header("content-type", "application/json")
  .body("{\n  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\n}")
  .asString();

const data = JSON.stringify({
  AssignmentStatus: '',
  PolicyArn: '',
  Identities: {}
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName',
  headers: {'content-type': 'application/json'},
  data: {AssignmentStatus: '', PolicyArn: '', Identities: {}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"AssignmentStatus":"","PolicyArn":"","Identities":{}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AssignmentStatus": "",\n  "PolicyArn": "",\n  "Identities": {}\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName',
  headers: {
    '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({AssignmentStatus: '', PolicyArn: '', Identities: {}}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName',
  headers: {'content-type': 'application/json'},
  body: {AssignmentStatus: '', PolicyArn: '', Identities: {}},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AssignmentStatus: '',
  PolicyArn: '',
  Identities: {}
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName',
  headers: {'content-type': 'application/json'},
  data: {AssignmentStatus: '', PolicyArn: '', Identities: {}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"AssignmentStatus":"","PolicyArn":"","Identities":{}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AssignmentStatus": @"",
                              @"PolicyArn": @"",
                              @"Identities": @{  } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'AssignmentStatus' => '',
    'PolicyArn' => '',
    'Identities' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName', [
  'body' => '{
  "AssignmentStatus": "",
  "PolicyArn": "",
  "Identities": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AssignmentStatus' => '',
  'PolicyArn' => '',
  'Identities' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AssignmentStatus' => '',
  'PolicyArn' => '',
  'Identities' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "AssignmentStatus": "",
  "PolicyArn": "",
  "Identities": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "AssignmentStatus": "",
  "PolicyArn": "",
  "Identities": {}
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName"

payload = {
    "AssignmentStatus": "",
    "PolicyArn": "",
    "Identities": {}
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName"

payload <- "{\n  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\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.put('/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName') do |req|
  req.body = "{\n  \"AssignmentStatus\": \"\",\n  \"PolicyArn\": \"\",\n  \"Identities\": {}\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName";

    let payload = json!({
        "AssignmentStatus": "",
        "PolicyArn": "",
        "Identities": json!({})
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName \
  --header 'content-type: application/json' \
  --data '{
  "AssignmentStatus": "",
  "PolicyArn": "",
  "Identities": {}
}'

echo '{
  "AssignmentStatus": "",
  "PolicyArn": "",
  "Identities": {}
}' |  \
  http PUT {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "AssignmentStatus": "",\n  "PolicyArn": "",\n  "Identities": {}\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "AssignmentStatus": "",
  "PolicyArn": "",
  "Identities": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/iam-policy-assignments/:AssignmentName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateIpRestriction

{{baseUrl}}/accounts/:AwsAccountId/ip-restriction

QUERY PARAMS

AwsAccountId

BODY json

{
  "IpRestrictionRuleMap": {},
  "Enabled": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/ip-restriction");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"IpRestrictionRuleMap\": {},\n  \"Enabled\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/accounts/:AwsAccountId/ip-restriction" {:content-type :json
                                                                                  :form-params {:IpRestrictionRuleMap {}
                                                                                                :Enabled false}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/ip-restriction"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"IpRestrictionRuleMap\": {},\n  \"Enabled\": false\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}}/accounts/:AwsAccountId/ip-restriction"),
    Content = new StringContent("{\n  \"IpRestrictionRuleMap\": {},\n  \"Enabled\": false\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}}/accounts/:AwsAccountId/ip-restriction");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"IpRestrictionRuleMap\": {},\n  \"Enabled\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/ip-restriction"

	payload := strings.NewReader("{\n  \"IpRestrictionRuleMap\": {},\n  \"Enabled\": false\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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/accounts/:AwsAccountId/ip-restriction HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 52

{
  "IpRestrictionRuleMap": {},
  "Enabled": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:AwsAccountId/ip-restriction")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"IpRestrictionRuleMap\": {},\n  \"Enabled\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/ip-restriction"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"IpRestrictionRuleMap\": {},\n  \"Enabled\": false\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  \"IpRestrictionRuleMap\": {},\n  \"Enabled\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/ip-restriction")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:AwsAccountId/ip-restriction")
  .header("content-type", "application/json")
  .body("{\n  \"IpRestrictionRuleMap\": {},\n  \"Enabled\": false\n}")
  .asString();

const data = JSON.stringify({
  IpRestrictionRuleMap: {},
  Enabled: false
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/accounts/:AwsAccountId/ip-restriction');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/ip-restriction',
  headers: {'content-type': 'application/json'},
  data: {IpRestrictionRuleMap: {}, Enabled: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/ip-restriction';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"IpRestrictionRuleMap":{},"Enabled":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/ip-restriction',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "IpRestrictionRuleMap": {},\n  "Enabled": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"IpRestrictionRuleMap\": {},\n  \"Enabled\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/ip-restriction")
  .post(body)
  .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/accounts/:AwsAccountId/ip-restriction',
  headers: {
    '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({IpRestrictionRuleMap: {}, Enabled: false}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/ip-restriction',
  headers: {'content-type': 'application/json'},
  body: {IpRestrictionRuleMap: {}, Enabled: false},
  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}}/accounts/:AwsAccountId/ip-restriction');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  IpRestrictionRuleMap: {},
  Enabled: false
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:AwsAccountId/ip-restriction',
  headers: {'content-type': 'application/json'},
  data: {IpRestrictionRuleMap: {}, Enabled: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/ip-restriction';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"IpRestrictionRuleMap":{},"Enabled":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"IpRestrictionRuleMap": @{  },
                              @"Enabled": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/ip-restriction"]
                                                       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}}/accounts/:AwsAccountId/ip-restriction" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"IpRestrictionRuleMap\": {},\n  \"Enabled\": false\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/ip-restriction",
  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([
    'IpRestrictionRuleMap' => [
        
    ],
    'Enabled' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/accounts/:AwsAccountId/ip-restriction', [
  'body' => '{
  "IpRestrictionRuleMap": {},
  "Enabled": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/ip-restriction');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'IpRestrictionRuleMap' => [
    
  ],
  'Enabled' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'IpRestrictionRuleMap' => [
    
  ],
  'Enabled' => null
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/ip-restriction');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/ip-restriction' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "IpRestrictionRuleMap": {},
  "Enabled": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/ip-restriction' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "IpRestrictionRuleMap": {},
  "Enabled": false
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"IpRestrictionRuleMap\": {},\n  \"Enabled\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/accounts/:AwsAccountId/ip-restriction", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/ip-restriction"

payload = {
    "IpRestrictionRuleMap": {},
    "Enabled": False
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/ip-restriction"

payload <- "{\n  \"IpRestrictionRuleMap\": {},\n  \"Enabled\": false\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/ip-restriction")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"IpRestrictionRuleMap\": {},\n  \"Enabled\": false\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/accounts/:AwsAccountId/ip-restriction') do |req|
  req.body = "{\n  \"IpRestrictionRuleMap\": {},\n  \"Enabled\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/ip-restriction";

    let payload = json!({
        "IpRestrictionRuleMap": json!({}),
        "Enabled": false
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/accounts/:AwsAccountId/ip-restriction \
  --header 'content-type: application/json' \
  --data '{
  "IpRestrictionRuleMap": {},
  "Enabled": false
}'

echo '{
  "IpRestrictionRuleMap": {},
  "Enabled": false
}' |  \
  http POST {{baseUrl}}/accounts/:AwsAccountId/ip-restriction \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "IpRestrictionRuleMap": {},\n  "Enabled": false\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/ip-restriction

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "IpRestrictionRuleMap": [],
  "Enabled": false
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/ip-restriction")! 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()

PUT UpdatePublicSharingSettings

{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings

QUERY PARAMS

AwsAccountId

BODY json

{
  "PublicSharingEnabled": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"PublicSharingEnabled\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings" {:content-type :json
                                                                                          :form-params {:PublicSharingEnabled false}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"PublicSharingEnabled\": false\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings"),
    Content = new StringContent("{\n  \"PublicSharingEnabled\": false\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}}/accounts/:AwsAccountId/public-sharing-settings");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"PublicSharingEnabled\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings"

	payload := strings.NewReader("{\n  \"PublicSharingEnabled\": false\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	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))

}

PUT /baseUrl/accounts/:AwsAccountId/public-sharing-settings HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 35

{
  "PublicSharingEnabled": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"PublicSharingEnabled\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"PublicSharingEnabled\": false\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  \"PublicSharingEnabled\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings")
  .header("content-type", "application/json")
  .body("{\n  \"PublicSharingEnabled\": false\n}")
  .asString();

const data = JSON.stringify({
  PublicSharingEnabled: false
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings',
  headers: {'content-type': 'application/json'},
  data: {PublicSharingEnabled: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"PublicSharingEnabled":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "PublicSharingEnabled": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"PublicSharingEnabled\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/public-sharing-settings',
  headers: {
    '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({PublicSharingEnabled: false}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings',
  headers: {'content-type': 'application/json'},
  body: {PublicSharingEnabled: false},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  PublicSharingEnabled: false
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings',
  headers: {'content-type': 'application/json'},
  data: {PublicSharingEnabled: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"PublicSharingEnabled":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"PublicSharingEnabled": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/accounts/:AwsAccountId/public-sharing-settings" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"PublicSharingEnabled\": false\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'PublicSharingEnabled' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings', [
  'body' => '{
  "PublicSharingEnabled": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'PublicSharingEnabled' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'PublicSharingEnabled' => null
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "PublicSharingEnabled": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "PublicSharingEnabled": false
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"PublicSharingEnabled\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/accounts/:AwsAccountId/public-sharing-settings", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings"

payload = { "PublicSharingEnabled": False }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings"

payload <- "{\n  \"PublicSharingEnabled\": false\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"PublicSharingEnabled\": false\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.put('/baseUrl/accounts/:AwsAccountId/public-sharing-settings') do |req|
  req.body = "{\n  \"PublicSharingEnabled\": false\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings";

    let payload = json!({"PublicSharingEnabled": false});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings \
  --header 'content-type: application/json' \
  --data '{
  "PublicSharingEnabled": false
}'

echo '{
  "PublicSharingEnabled": false
}' |  \
  http PUT {{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "PublicSharingEnabled": false\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["PublicSharingEnabled": false] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/public-sharing-settings")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

PUT UpdateRefreshSchedule

{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules

QUERY PARAMS

DataSetId

AwsAccountId

BODY json

{
  "Schedule": {
    "ScheduleId": "",
    "ScheduleFrequency": "",
    "StartAfterDateTime": "",
    "RefreshType": "",
    "Arn": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules" {:content-type :json
                                                                                                         :form-params {:Schedule {:ScheduleId ""
                                                                                                                                  :ScheduleFrequency ""
                                                                                                                                  :StartAfterDateTime ""
                                                                                                                                  :RefreshType ""
                                                                                                                                  :Arn ""}}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\n  }\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules"),
    Content = new StringContent("{\n  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\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}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules"

	payload := strings.NewReader("{\n  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\n  }\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	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))

}

PUT /baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 141

{
  "Schedule": {
    "ScheduleId": "",
    "ScheduleFrequency": "",
    "StartAfterDateTime": "",
    "RefreshType": "",
    "Arn": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\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  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules")
  .header("content-type", "application/json")
  .body("{\n  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  Schedule: {
    ScheduleId: '',
    ScheduleFrequency: '',
    StartAfterDateTime: '',
    RefreshType: '',
    Arn: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules',
  headers: {'content-type': 'application/json'},
  data: {
    Schedule: {
      ScheduleId: '',
      ScheduleFrequency: '',
      StartAfterDateTime: '',
      RefreshType: '',
      Arn: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Schedule":{"ScheduleId":"","ScheduleFrequency":"","StartAfterDateTime":"","RefreshType":"","Arn":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Schedule": {\n    "ScheduleId": "",\n    "ScheduleFrequency": "",\n    "StartAfterDateTime": "",\n    "RefreshType": "",\n    "Arn": ""\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  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules',
  headers: {
    '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({
  Schedule: {
    ScheduleId: '',
    ScheduleFrequency: '',
    StartAfterDateTime: '',
    RefreshType: '',
    Arn: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules',
  headers: {'content-type': 'application/json'},
  body: {
    Schedule: {
      ScheduleId: '',
      ScheduleFrequency: '',
      StartAfterDateTime: '',
      RefreshType: '',
      Arn: ''
    }
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Schedule: {
    ScheduleId: '',
    ScheduleFrequency: '',
    StartAfterDateTime: '',
    RefreshType: '',
    Arn: ''
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules',
  headers: {'content-type': 'application/json'},
  data: {
    Schedule: {
      ScheduleId: '',
      ScheduleFrequency: '',
      StartAfterDateTime: '',
      RefreshType: '',
      Arn: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Schedule":{"ScheduleId":"","ScheduleFrequency":"","StartAfterDateTime":"","RefreshType":"","Arn":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Schedule": @{ @"ScheduleId": @"", @"ScheduleFrequency": @"", @"StartAfterDateTime": @"", @"RefreshType": @"", @"Arn": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'Schedule' => [
        'ScheduleId' => '',
        'ScheduleFrequency' => '',
        'StartAfterDateTime' => '',
        'RefreshType' => '',
        'Arn' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules', [
  'body' => '{
  "Schedule": {
    "ScheduleId": "",
    "ScheduleFrequency": "",
    "StartAfterDateTime": "",
    "RefreshType": "",
    "Arn": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Schedule' => [
    'ScheduleId' => '',
    'ScheduleFrequency' => '',
    'StartAfterDateTime' => '',
    'RefreshType' => '',
    'Arn' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Schedule' => [
    'ScheduleId' => '',
    'ScheduleFrequency' => '',
    'StartAfterDateTime' => '',
    'RefreshType' => '',
    'Arn' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Schedule": {
    "ScheduleId": "",
    "ScheduleFrequency": "",
    "StartAfterDateTime": "",
    "RefreshType": "",
    "Arn": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Schedule": {
    "ScheduleId": "",
    "ScheduleFrequency": "",
    "StartAfterDateTime": "",
    "RefreshType": "",
    "Arn": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules"

payload = { "Schedule": {
        "ScheduleId": "",
        "ScheduleFrequency": "",
        "StartAfterDateTime": "",
        "RefreshType": "",
        "Arn": ""
    } }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules"

payload <- "{\n  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\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.put('/baseUrl/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules') do |req|
  req.body = "{\n  \"Schedule\": {\n    \"ScheduleId\": \"\",\n    \"ScheduleFrequency\": \"\",\n    \"StartAfterDateTime\": \"\",\n    \"RefreshType\": \"\",\n    \"Arn\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules";

    let payload = json!({"Schedule": json!({
            "ScheduleId": "",
            "ScheduleFrequency": "",
            "StartAfterDateTime": "",
            "RefreshType": "",
            "Arn": ""
        })});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules \
  --header 'content-type: application/json' \
  --data '{
  "Schedule": {
    "ScheduleId": "",
    "ScheduleFrequency": "",
    "StartAfterDateTime": "",
    "RefreshType": "",
    "Arn": ""
  }
}'

echo '{
  "Schedule": {
    "ScheduleId": "",
    "ScheduleFrequency": "",
    "StartAfterDateTime": "",
    "RefreshType": "",
    "Arn": ""
  }
}' |  \
  http PUT {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "Schedule": {\n    "ScheduleId": "",\n    "ScheduleFrequency": "",\n    "StartAfterDateTime": "",\n    "RefreshType": "",\n    "Arn": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["Schedule": [
    "ScheduleId": "",
    "ScheduleFrequency": "",
    "StartAfterDateTime": "",
    "RefreshType": "",
    "Arn": ""
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/data-sets/:DataSetId/refresh-schedules")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

PUT UpdateTemplate

{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId

QUERY PARAMS

AwsAccountId

TemplateId

BODY json

{
  "SourceEntity": {
    "SourceAnalysis": "",
    "SourceTemplate": ""
  },
  "VersionDescription": "",
  "Name": "",
  "Definition": {
    "DataSetConfigurations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"Name\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId" {:content-type :json
                                                                                        :form-params {:SourceEntity {:SourceAnalysis ""
                                                                                                                     :SourceTemplate ""}
                                                                                                      :VersionDescription ""
                                                                                                      :Name ""
                                                                                                      :Definition {:DataSetConfigurations ""
                                                                                                                   :Sheets ""
                                                                                                                   :CalculatedFields ""
                                                                                                                   :ParameterDeclarations ""
                                                                                                                   :FilterGroups ""
                                                                                                                   :ColumnConfigurations ""
                                                                                                                   :AnalysisDefaults {:DefaultNewSheetConfiguration ""}}}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"Name\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId"),
    Content = new StringContent("{\n  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"Name\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\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}}/accounts/:AwsAccountId/templates/:TemplateId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"Name\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId"

	payload := strings.NewReader("{\n  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"Name\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	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))

}

PUT /baseUrl/accounts/:AwsAccountId/templates/:TemplateId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 384

{
  "SourceEntity": {
    "SourceAnalysis": "",
    "SourceTemplate": ""
  },
  "VersionDescription": "",
  "Name": "",
  "Definition": {
    "DataSetConfigurations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"Name\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"Name\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\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  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"Name\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId")
  .header("content-type", "application/json")
  .body("{\n  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"Name\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}")
  .asString();

const data = JSON.stringify({
  SourceEntity: {
    SourceAnalysis: '',
    SourceTemplate: ''
  },
  VersionDescription: '',
  Name: '',
  Definition: {
    DataSetConfigurations: '',
    Sheets: '',
    CalculatedFields: '',
    ParameterDeclarations: '',
    FilterGroups: '',
    ColumnConfigurations: '',
    AnalysisDefaults: {
      DefaultNewSheetConfiguration: ''
    }
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId',
  headers: {'content-type': 'application/json'},
  data: {
    SourceEntity: {SourceAnalysis: '', SourceTemplate: ''},
    VersionDescription: '',
    Name: '',
    Definition: {
      DataSetConfigurations: '',
      Sheets: '',
      CalculatedFields: '',
      ParameterDeclarations: '',
      FilterGroups: '',
      ColumnConfigurations: '',
      AnalysisDefaults: {DefaultNewSheetConfiguration: ''}
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"SourceEntity":{"SourceAnalysis":"","SourceTemplate":""},"VersionDescription":"","Name":"","Definition":{"DataSetConfigurations":"","Sheets":"","CalculatedFields":"","ParameterDeclarations":"","FilterGroups":"","ColumnConfigurations":"","AnalysisDefaults":{"DefaultNewSheetConfiguration":""}}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "SourceEntity": {\n    "SourceAnalysis": "",\n    "SourceTemplate": ""\n  },\n  "VersionDescription": "",\n  "Name": "",\n  "Definition": {\n    "DataSetConfigurations": "",\n    "Sheets": "",\n    "CalculatedFields": "",\n    "ParameterDeclarations": "",\n    "FilterGroups": "",\n    "ColumnConfigurations": "",\n    "AnalysisDefaults": {\n      "DefaultNewSheetConfiguration": ""\n    }\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  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"Name\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/templates/:TemplateId',
  headers: {
    '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({
  SourceEntity: {SourceAnalysis: '', SourceTemplate: ''},
  VersionDescription: '',
  Name: '',
  Definition: {
    DataSetConfigurations: '',
    Sheets: '',
    CalculatedFields: '',
    ParameterDeclarations: '',
    FilterGroups: '',
    ColumnConfigurations: '',
    AnalysisDefaults: {DefaultNewSheetConfiguration: ''}
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId',
  headers: {'content-type': 'application/json'},
  body: {
    SourceEntity: {SourceAnalysis: '', SourceTemplate: ''},
    VersionDescription: '',
    Name: '',
    Definition: {
      DataSetConfigurations: '',
      Sheets: '',
      CalculatedFields: '',
      ParameterDeclarations: '',
      FilterGroups: '',
      ColumnConfigurations: '',
      AnalysisDefaults: {DefaultNewSheetConfiguration: ''}
    }
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  SourceEntity: {
    SourceAnalysis: '',
    SourceTemplate: ''
  },
  VersionDescription: '',
  Name: '',
  Definition: {
    DataSetConfigurations: '',
    Sheets: '',
    CalculatedFields: '',
    ParameterDeclarations: '',
    FilterGroups: '',
    ColumnConfigurations: '',
    AnalysisDefaults: {
      DefaultNewSheetConfiguration: ''
    }
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId',
  headers: {'content-type': 'application/json'},
  data: {
    SourceEntity: {SourceAnalysis: '', SourceTemplate: ''},
    VersionDescription: '',
    Name: '',
    Definition: {
      DataSetConfigurations: '',
      Sheets: '',
      CalculatedFields: '',
      ParameterDeclarations: '',
      FilterGroups: '',
      ColumnConfigurations: '',
      AnalysisDefaults: {DefaultNewSheetConfiguration: ''}
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"SourceEntity":{"SourceAnalysis":"","SourceTemplate":""},"VersionDescription":"","Name":"","Definition":{"DataSetConfigurations":"","Sheets":"","CalculatedFields":"","ParameterDeclarations":"","FilterGroups":"","ColumnConfigurations":"","AnalysisDefaults":{"DefaultNewSheetConfiguration":""}}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"SourceEntity": @{ @"SourceAnalysis": @"", @"SourceTemplate": @"" },
                              @"VersionDescription": @"",
                              @"Name": @"",
                              @"Definition": @{ @"DataSetConfigurations": @"", @"Sheets": @"", @"CalculatedFields": @"", @"ParameterDeclarations": @"", @"FilterGroups": @"", @"ColumnConfigurations": @"", @"AnalysisDefaults": @{ @"DefaultNewSheetConfiguration": @"" } } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/accounts/:AwsAccountId/templates/:TemplateId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"Name\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'SourceEntity' => [
        'SourceAnalysis' => '',
        'SourceTemplate' => ''
    ],
    'VersionDescription' => '',
    'Name' => '',
    'Definition' => [
        'DataSetConfigurations' => '',
        'Sheets' => '',
        'CalculatedFields' => '',
        'ParameterDeclarations' => '',
        'FilterGroups' => '',
        'ColumnConfigurations' => '',
        'AnalysisDefaults' => [
                'DefaultNewSheetConfiguration' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId', [
  'body' => '{
  "SourceEntity": {
    "SourceAnalysis": "",
    "SourceTemplate": ""
  },
  "VersionDescription": "",
  "Name": "",
  "Definition": {
    "DataSetConfigurations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'SourceEntity' => [
    'SourceAnalysis' => '',
    'SourceTemplate' => ''
  ],
  'VersionDescription' => '',
  'Name' => '',
  'Definition' => [
    'DataSetConfigurations' => '',
    'Sheets' => '',
    'CalculatedFields' => '',
    'ParameterDeclarations' => '',
    'FilterGroups' => '',
    'ColumnConfigurations' => '',
    'AnalysisDefaults' => [
        'DefaultNewSheetConfiguration' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'SourceEntity' => [
    'SourceAnalysis' => '',
    'SourceTemplate' => ''
  ],
  'VersionDescription' => '',
  'Name' => '',
  'Definition' => [
    'DataSetConfigurations' => '',
    'Sheets' => '',
    'CalculatedFields' => '',
    'ParameterDeclarations' => '',
    'FilterGroups' => '',
    'ColumnConfigurations' => '',
    'AnalysisDefaults' => [
        'DefaultNewSheetConfiguration' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "SourceEntity": {
    "SourceAnalysis": "",
    "SourceTemplate": ""
  },
  "VersionDescription": "",
  "Name": "",
  "Definition": {
    "DataSetConfigurations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "SourceEntity": {
    "SourceAnalysis": "",
    "SourceTemplate": ""
  },
  "VersionDescription": "",
  "Name": "",
  "Definition": {
    "DataSetConfigurations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"Name\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/accounts/:AwsAccountId/templates/:TemplateId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId"

payload = {
    "SourceEntity": {
        "SourceAnalysis": "",
        "SourceTemplate": ""
    },
    "VersionDescription": "",
    "Name": "",
    "Definition": {
        "DataSetConfigurations": "",
        "Sheets": "",
        "CalculatedFields": "",
        "ParameterDeclarations": "",
        "FilterGroups": "",
        "ColumnConfigurations": "",
        "AnalysisDefaults": { "DefaultNewSheetConfiguration": "" }
    }
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId"

payload <- "{\n  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"Name\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"Name\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\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.put('/baseUrl/accounts/:AwsAccountId/templates/:TemplateId') do |req|
  req.body = "{\n  \"SourceEntity\": {\n    \"SourceAnalysis\": \"\",\n    \"SourceTemplate\": \"\"\n  },\n  \"VersionDescription\": \"\",\n  \"Name\": \"\",\n  \"Definition\": {\n    \"DataSetConfigurations\": \"\",\n    \"Sheets\": \"\",\n    \"CalculatedFields\": \"\",\n    \"ParameterDeclarations\": \"\",\n    \"FilterGroups\": \"\",\n    \"ColumnConfigurations\": \"\",\n    \"AnalysisDefaults\": {\n      \"DefaultNewSheetConfiguration\": \"\"\n    }\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId";

    let payload = json!({
        "SourceEntity": json!({
            "SourceAnalysis": "",
            "SourceTemplate": ""
        }),
        "VersionDescription": "",
        "Name": "",
        "Definition": json!({
            "DataSetConfigurations": "",
            "Sheets": "",
            "CalculatedFields": "",
            "ParameterDeclarations": "",
            "FilterGroups": "",
            "ColumnConfigurations": "",
            "AnalysisDefaults": json!({"DefaultNewSheetConfiguration": ""})
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId \
  --header 'content-type: application/json' \
  --data '{
  "SourceEntity": {
    "SourceAnalysis": "",
    "SourceTemplate": ""
  },
  "VersionDescription": "",
  "Name": "",
  "Definition": {
    "DataSetConfigurations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}'

echo '{
  "SourceEntity": {
    "SourceAnalysis": "",
    "SourceTemplate": ""
  },
  "VersionDescription": "",
  "Name": "",
  "Definition": {
    "DataSetConfigurations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": {
      "DefaultNewSheetConfiguration": ""
    }
  }
}' |  \
  http PUT {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "SourceEntity": {\n    "SourceAnalysis": "",\n    "SourceTemplate": ""\n  },\n  "VersionDescription": "",\n  "Name": "",\n  "Definition": {\n    "DataSetConfigurations": "",\n    "Sheets": "",\n    "CalculatedFields": "",\n    "ParameterDeclarations": "",\n    "FilterGroups": "",\n    "ColumnConfigurations": "",\n    "AnalysisDefaults": {\n      "DefaultNewSheetConfiguration": ""\n    }\n  }\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "SourceEntity": [
    "SourceAnalysis": "",
    "SourceTemplate": ""
  ],
  "VersionDescription": "",
  "Name": "",
  "Definition": [
    "DataSetConfigurations": "",
    "Sheets": "",
    "CalculatedFields": "",
    "ParameterDeclarations": "",
    "FilterGroups": "",
    "ColumnConfigurations": "",
    "AnalysisDefaults": ["DefaultNewSheetConfiguration": ""]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

PUT UpdateTemplateAlias

{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName

QUERY PARAMS

AwsAccountId

TemplateId

AliasName

BODY json

{
  "TemplateVersionNumber": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"TemplateVersionNumber\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName" {:content-type :json
                                                                                                           :form-params {:TemplateVersionNumber 0}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"TemplateVersionNumber\": 0\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName"),
    Content = new StringContent("{\n  \"TemplateVersionNumber\": 0\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}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TemplateVersionNumber\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName"

	payload := strings.NewReader("{\n  \"TemplateVersionNumber\": 0\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	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))

}

PUT /baseUrl/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 32

{
  "TemplateVersionNumber": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TemplateVersionNumber\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"TemplateVersionNumber\": 0\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  \"TemplateVersionNumber\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName")
  .header("content-type", "application/json")
  .body("{\n  \"TemplateVersionNumber\": 0\n}")
  .asString();

const data = JSON.stringify({
  TemplateVersionNumber: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName',
  headers: {'content-type': 'application/json'},
  data: {TemplateVersionNumber: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"TemplateVersionNumber":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TemplateVersionNumber": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TemplateVersionNumber\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName',
  headers: {
    '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({TemplateVersionNumber: 0}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName',
  headers: {'content-type': 'application/json'},
  body: {TemplateVersionNumber: 0},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TemplateVersionNumber: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName',
  headers: {'content-type': 'application/json'},
  data: {TemplateVersionNumber: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"TemplateVersionNumber":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"TemplateVersionNumber": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"TemplateVersionNumber\": 0\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'TemplateVersionNumber' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName', [
  'body' => '{
  "TemplateVersionNumber": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TemplateVersionNumber' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TemplateVersionNumber' => 0
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "TemplateVersionNumber": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "TemplateVersionNumber": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TemplateVersionNumber\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName"

payload = { "TemplateVersionNumber": 0 }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName"

payload <- "{\n  \"TemplateVersionNumber\": 0\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"TemplateVersionNumber\": 0\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.put('/baseUrl/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName') do |req|
  req.body = "{\n  \"TemplateVersionNumber\": 0\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName";

    let payload = json!({"TemplateVersionNumber": 0});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName \
  --header 'content-type: application/json' \
  --data '{
  "TemplateVersionNumber": 0
}'

echo '{
  "TemplateVersionNumber": 0
}' |  \
  http PUT {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "TemplateVersionNumber": 0\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["TemplateVersionNumber": 0] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/aliases/:AliasName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

PUT UpdateTemplatePermissions

{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions

QUERY PARAMS

AwsAccountId

TemplateId

BODY json

{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions" {:content-type :json
                                                                                                    :form-params {:GrantPermissions [{:Principal ""
                                                                                                                                      :Actions ""}]
                                                                                                                  :RevokePermissions [{}]}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions"),
    Content = new StringContent("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\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}}/accounts/:AwsAccountId/templates/:TemplateId/permissions");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions"

	payload := strings.NewReader("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	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))

}

PUT /baseUrl/accounts/:AwsAccountId/templates/:TemplateId/permissions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 123

{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\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  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions")
  .header("content-type", "application/json")
  .body("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}")
  .asString();

const data = JSON.stringify({
  GrantPermissions: [
    {
      Principal: '',
      Actions: ''
    }
  ],
  RevokePermissions: [
    {}
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions',
  headers: {'content-type': 'application/json'},
  data: {GrantPermissions: [{Principal: '', Actions: ''}], RevokePermissions: [{}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"GrantPermissions":[{"Principal":"","Actions":""}],"RevokePermissions":[{}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GrantPermissions": [\n    {\n      "Principal": "",\n      "Actions": ""\n    }\n  ],\n  "RevokePermissions": [\n    {}\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  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/templates/:TemplateId/permissions',
  headers: {
    '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({GrantPermissions: [{Principal: '', Actions: ''}], RevokePermissions: [{}]}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions',
  headers: {'content-type': 'application/json'},
  body: {GrantPermissions: [{Principal: '', Actions: ''}], RevokePermissions: [{}]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GrantPermissions: [
    {
      Principal: '',
      Actions: ''
    }
  ],
  RevokePermissions: [
    {}
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions',
  headers: {'content-type': 'application/json'},
  data: {GrantPermissions: [{Principal: '', Actions: ''}], RevokePermissions: [{}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"GrantPermissions":[{"Principal":"","Actions":""}],"RevokePermissions":[{}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GrantPermissions": @[ @{ @"Principal": @"", @"Actions": @"" } ],
                              @"RevokePermissions": @[ @{  } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/accounts/:AwsAccountId/templates/:TemplateId/permissions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'GrantPermissions' => [
        [
                'Principal' => '',
                'Actions' => ''
        ]
    ],
    'RevokePermissions' => [
        [
                
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions', [
  'body' => '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GrantPermissions' => [
    [
        'Principal' => '',
        'Actions' => ''
    ]
  ],
  'RevokePermissions' => [
    [
        
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GrantPermissions' => [
    [
        'Principal' => '',
        'Actions' => ''
    ]
  ],
  'RevokePermissions' => [
    [
        
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/accounts/:AwsAccountId/templates/:TemplateId/permissions", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions"

payload = {
    "GrantPermissions": [
        {
            "Principal": "",
            "Actions": ""
        }
    ],
    "RevokePermissions": [{}]
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions"

payload <- "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\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.put('/baseUrl/accounts/:AwsAccountId/templates/:TemplateId/permissions') do |req|
  req.body = "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions";

    let payload = json!({
        "GrantPermissions": (
            json!({
                "Principal": "",
                "Actions": ""
            })
        ),
        "RevokePermissions": (json!({}))
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions \
  --header 'content-type: application/json' \
  --data '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}'

echo '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}' |  \
  http PUT {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "GrantPermissions": [\n    {\n      "Principal": "",\n      "Actions": ""\n    }\n  ],\n  "RevokePermissions": [\n    {}\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "GrantPermissions": [
    [
      "Principal": "",
      "Actions": ""
    ]
  ],
  "RevokePermissions": [[]]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/templates/:TemplateId/permissions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

PUT UpdateTheme

{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId

QUERY PARAMS

AwsAccountId

ThemeId

BODY json

{
  "Name": "",
  "BaseThemeId": "",
  "VersionDescription": "",
  "Configuration": {
    "DataColorPalette": "",
    "UIColorPalette": "",
    "Sheet": "",
    "Typography": {
      "FontFamilies": ""
    }
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId");

struct curl_slist *headers = NULL;
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  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId" {:content-type :json
                                                                                  :form-params {:Name ""
                                                                                                :BaseThemeId ""
                                                                                                :VersionDescription ""
                                                                                                :Configuration {:DataColorPalette ""
                                                                                                                :UIColorPalette ""
                                                                                                                :Sheet ""
                                                                                                                :Typography {:FontFamilies ""}}}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\n  }\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\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}}/accounts/:AwsAccountId/themes/:ThemeId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\n  }\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	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))

}

PUT /baseUrl/accounts/:AwsAccountId/themes/:ThemeId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 213

{
  "Name": "",
  "BaseThemeId": "",
  "VersionDescription": "",
  "Configuration": {
    "DataColorPalette": "",
    "UIColorPalette": "",
    "Sheet": "",
    "Typography": {
      "FontFamilies": ""
    }
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\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  \"Name\": \"\",\n  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\n  }\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  BaseThemeId: '',
  VersionDescription: '',
  Configuration: {
    DataColorPalette: '',
    UIColorPalette: '',
    Sheet: '',
    Typography: {
      FontFamilies: ''
    }
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    BaseThemeId: '',
    VersionDescription: '',
    Configuration: {
      DataColorPalette: '',
      UIColorPalette: '',
      Sheet: '',
      Typography: {FontFamilies: ''}
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","BaseThemeId":"","VersionDescription":"","Configuration":{"DataColorPalette":"","UIColorPalette":"","Sheet":"","Typography":{"FontFamilies":""}}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "BaseThemeId": "",\n  "VersionDescription": "",\n  "Configuration": {\n    "DataColorPalette": "",\n    "UIColorPalette": "",\n    "Sheet": "",\n    "Typography": {\n      "FontFamilies": ""\n    }\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  \"Name\": \"\",\n  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/themes/:ThemeId',
  headers: {
    '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: '',
  BaseThemeId: '',
  VersionDescription: '',
  Configuration: {
    DataColorPalette: '',
    UIColorPalette: '',
    Sheet: '',
    Typography: {FontFamilies: ''}
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId',
  headers: {'content-type': 'application/json'},
  body: {
    Name: '',
    BaseThemeId: '',
    VersionDescription: '',
    Configuration: {
      DataColorPalette: '',
      UIColorPalette: '',
      Sheet: '',
      Typography: {FontFamilies: ''}
    }
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: '',
  BaseThemeId: '',
  VersionDescription: '',
  Configuration: {
    DataColorPalette: '',
    UIColorPalette: '',
    Sheet: '',
    Typography: {
      FontFamilies: ''
    }
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    BaseThemeId: '',
    VersionDescription: '',
    Configuration: {
      DataColorPalette: '',
      UIColorPalette: '',
      Sheet: '',
      Typography: {FontFamilies: ''}
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","BaseThemeId":"","VersionDescription":"","Configuration":{"DataColorPalette":"","UIColorPalette":"","Sheet":"","Typography":{"FontFamilies":""}}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"BaseThemeId": @"",
                              @"VersionDescription": @"",
                              @"Configuration": @{ @"DataColorPalette": @"", @"UIColorPalette": @"", @"Sheet": @"", @"Typography": @{ @"FontFamilies": @"" } } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/accounts/:AwsAccountId/themes/:ThemeId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'BaseThemeId' => '',
    'VersionDescription' => '',
    'Configuration' => [
        'DataColorPalette' => '',
        'UIColorPalette' => '',
        'Sheet' => '',
        'Typography' => [
                'FontFamilies' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId', [
  'body' => '{
  "Name": "",
  "BaseThemeId": "",
  "VersionDescription": "",
  "Configuration": {
    "DataColorPalette": "",
    "UIColorPalette": "",
    "Sheet": "",
    "Typography": {
      "FontFamilies": ""
    }
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'BaseThemeId' => '',
  'VersionDescription' => '',
  'Configuration' => [
    'DataColorPalette' => '',
    'UIColorPalette' => '',
    'Sheet' => '',
    'Typography' => [
        'FontFamilies' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => '',
  'BaseThemeId' => '',
  'VersionDescription' => '',
  'Configuration' => [
    'DataColorPalette' => '',
    'UIColorPalette' => '',
    'Sheet' => '',
    'Typography' => [
        'FontFamilies' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "BaseThemeId": "",
  "VersionDescription": "",
  "Configuration": {
    "DataColorPalette": "",
    "UIColorPalette": "",
    "Sheet": "",
    "Typography": {
      "FontFamilies": ""
    }
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "BaseThemeId": "",
  "VersionDescription": "",
  "Configuration": {
    "DataColorPalette": "",
    "UIColorPalette": "",
    "Sheet": "",
    "Typography": {
      "FontFamilies": ""
    }
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\",\n  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/accounts/:AwsAccountId/themes/:ThemeId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId"

payload = {
    "Name": "",
    "BaseThemeId": "",
    "VersionDescription": "",
    "Configuration": {
        "DataColorPalette": "",
        "UIColorPalette": "",
        "Sheet": "",
        "Typography": { "FontFamilies": "" }
    }
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId"

payload <- "{\n  \"Name\": \"\",\n  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\n  }\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\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.put('/baseUrl/accounts/:AwsAccountId/themes/:ThemeId') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"BaseThemeId\": \"\",\n  \"VersionDescription\": \"\",\n  \"Configuration\": {\n    \"DataColorPalette\": \"\",\n    \"UIColorPalette\": \"\",\n    \"Sheet\": \"\",\n    \"Typography\": {\n      \"FontFamilies\": \"\"\n    }\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId";

    let payload = json!({
        "Name": "",
        "BaseThemeId": "",
        "VersionDescription": "",
        "Configuration": json!({
            "DataColorPalette": "",
            "UIColorPalette": "",
            "Sheet": "",
            "Typography": json!({"FontFamilies": ""})
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId \
  --header 'content-type: application/json' \
  --data '{
  "Name": "",
  "BaseThemeId": "",
  "VersionDescription": "",
  "Configuration": {
    "DataColorPalette": "",
    "UIColorPalette": "",
    "Sheet": "",
    "Typography": {
      "FontFamilies": ""
    }
  }
}'

echo '{
  "Name": "",
  "BaseThemeId": "",
  "VersionDescription": "",
  "Configuration": {
    "DataColorPalette": "",
    "UIColorPalette": "",
    "Sheet": "",
    "Typography": {
      "FontFamilies": ""
    }
  }
}' |  \
  http PUT {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "BaseThemeId": "",\n  "VersionDescription": "",\n  "Configuration": {\n    "DataColorPalette": "",\n    "UIColorPalette": "",\n    "Sheet": "",\n    "Typography": {\n      "FontFamilies": ""\n    }\n  }\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "BaseThemeId": "",
  "VersionDescription": "",
  "Configuration": [
    "DataColorPalette": "",
    "UIColorPalette": "",
    "Sheet": "",
    "Typography": ["FontFamilies": ""]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

PUT UpdateThemeAlias

{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName

QUERY PARAMS

AwsAccountId

ThemeId

AliasName

BODY json

{
  "ThemeVersionNumber": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"ThemeVersionNumber\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName" {:content-type :json
                                                                                                     :form-params {:ThemeVersionNumber 0}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ThemeVersionNumber\": 0\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName"),
    Content = new StringContent("{\n  \"ThemeVersionNumber\": 0\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}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ThemeVersionNumber\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName"

	payload := strings.NewReader("{\n  \"ThemeVersionNumber\": 0\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	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))

}

PUT /baseUrl/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 29

{
  "ThemeVersionNumber": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ThemeVersionNumber\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"ThemeVersionNumber\": 0\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  \"ThemeVersionNumber\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName")
  .header("content-type", "application/json")
  .body("{\n  \"ThemeVersionNumber\": 0\n}")
  .asString();

const data = JSON.stringify({
  ThemeVersionNumber: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName',
  headers: {'content-type': 'application/json'},
  data: {ThemeVersionNumber: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"ThemeVersionNumber":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ThemeVersionNumber": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ThemeVersionNumber\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName',
  headers: {
    '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({ThemeVersionNumber: 0}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName',
  headers: {'content-type': 'application/json'},
  body: {ThemeVersionNumber: 0},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ThemeVersionNumber: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName',
  headers: {'content-type': 'application/json'},
  data: {ThemeVersionNumber: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"ThemeVersionNumber":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ThemeVersionNumber": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ThemeVersionNumber\": 0\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'ThemeVersionNumber' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName', [
  'body' => '{
  "ThemeVersionNumber": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ThemeVersionNumber' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ThemeVersionNumber' => 0
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "ThemeVersionNumber": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "ThemeVersionNumber": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ThemeVersionNumber\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName"

payload = { "ThemeVersionNumber": 0 }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName"

payload <- "{\n  \"ThemeVersionNumber\": 0\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"ThemeVersionNumber\": 0\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.put('/baseUrl/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName') do |req|
  req.body = "{\n  \"ThemeVersionNumber\": 0\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName";

    let payload = json!({"ThemeVersionNumber": 0});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName \
  --header 'content-type: application/json' \
  --data '{
  "ThemeVersionNumber": 0
}'

echo '{
  "ThemeVersionNumber": 0
}' |  \
  http PUT {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "ThemeVersionNumber": 0\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["ThemeVersionNumber": 0] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/aliases/:AliasName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

PUT UpdateThemePermissions

{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions

QUERY PARAMS

AwsAccountId

ThemeId

BODY json

{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions" {:content-type :json
                                                                                              :form-params {:GrantPermissions [{:Principal ""
                                                                                                                                :Actions ""}]
                                                                                                            :RevokePermissions [{}]}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions"),
    Content = new StringContent("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\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}}/accounts/:AwsAccountId/themes/:ThemeId/permissions");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions"

	payload := strings.NewReader("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	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))

}

PUT /baseUrl/accounts/:AwsAccountId/themes/:ThemeId/permissions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 123

{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\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  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions")
  .header("content-type", "application/json")
  .body("{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}")
  .asString();

const data = JSON.stringify({
  GrantPermissions: [
    {
      Principal: '',
      Actions: ''
    }
  ],
  RevokePermissions: [
    {}
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions',
  headers: {'content-type': 'application/json'},
  data: {GrantPermissions: [{Principal: '', Actions: ''}], RevokePermissions: [{}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"GrantPermissions":[{"Principal":"","Actions":""}],"RevokePermissions":[{}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GrantPermissions": [\n    {\n      "Principal": "",\n      "Actions": ""\n    }\n  ],\n  "RevokePermissions": [\n    {}\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  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/themes/:ThemeId/permissions',
  headers: {
    '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({GrantPermissions: [{Principal: '', Actions: ''}], RevokePermissions: [{}]}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions',
  headers: {'content-type': 'application/json'},
  body: {GrantPermissions: [{Principal: '', Actions: ''}], RevokePermissions: [{}]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GrantPermissions: [
    {
      Principal: '',
      Actions: ''
    }
  ],
  RevokePermissions: [
    {}
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions',
  headers: {'content-type': 'application/json'},
  data: {GrantPermissions: [{Principal: '', Actions: ''}], RevokePermissions: [{}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"GrantPermissions":[{"Principal":"","Actions":""}],"RevokePermissions":[{}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GrantPermissions": @[ @{ @"Principal": @"", @"Actions": @"" } ],
                              @"RevokePermissions": @[ @{  } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/accounts/:AwsAccountId/themes/:ThemeId/permissions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'GrantPermissions' => [
        [
                'Principal' => '',
                'Actions' => ''
        ]
    ],
    'RevokePermissions' => [
        [
                
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions', [
  'body' => '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GrantPermissions' => [
    [
        'Principal' => '',
        'Actions' => ''
    ]
  ],
  'RevokePermissions' => [
    [
        
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GrantPermissions' => [
    [
        'Principal' => '',
        'Actions' => ''
    ]
  ],
  'RevokePermissions' => [
    [
        
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/accounts/:AwsAccountId/themes/:ThemeId/permissions", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions"

payload = {
    "GrantPermissions": [
        {
            "Principal": "",
            "Actions": ""
        }
    ],
    "RevokePermissions": [{}]
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions"

payload <- "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\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.put('/baseUrl/accounts/:AwsAccountId/themes/:ThemeId/permissions') do |req|
  req.body = "{\n  \"GrantPermissions\": [\n    {\n      \"Principal\": \"\",\n      \"Actions\": \"\"\n    }\n  ],\n  \"RevokePermissions\": [\n    {}\n  ]\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions";

    let payload = json!({
        "GrantPermissions": (
            json!({
                "Principal": "",
                "Actions": ""
            })
        ),
        "RevokePermissions": (json!({}))
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions \
  --header 'content-type: application/json' \
  --data '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}'

echo '{
  "GrantPermissions": [
    {
      "Principal": "",
      "Actions": ""
    }
  ],
  "RevokePermissions": [
    {}
  ]
}' |  \
  http PUT {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "GrantPermissions": [\n    {\n      "Principal": "",\n      "Actions": ""\n    }\n  ],\n  "RevokePermissions": [\n    {}\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "GrantPermissions": [
    [
      "Principal": "",
      "Actions": ""
    ]
  ],
  "RevokePermissions": [[]]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/themes/:ThemeId/permissions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

PUT UpdateUser

{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName

QUERY PARAMS

UserName

AwsAccountId

Namespace

BODY json

{
  "Email": "",
  "Role": "",
  "CustomPermissionsName": "",
  "UnapplyCustomPermissions": false,
  "ExternalLoginFederationProviderType": "",
  "CustomFederationProviderUrl": "",
  "ExternalLoginId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Email\": \"\",\n  \"Role\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"UnapplyCustomPermissions\": false,\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName" {:content-type :json
                                                                                                        :form-params {:Email ""
                                                                                                                      :Role ""
                                                                                                                      :CustomPermissionsName ""
                                                                                                                      :UnapplyCustomPermissions false
                                                                                                                      :ExternalLoginFederationProviderType ""
                                                                                                                      :CustomFederationProviderUrl ""
                                                                                                                      :ExternalLoginId ""}})

require "http/client"

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Email\": \"\",\n  \"Role\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"UnapplyCustomPermissions\": false,\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName"),
    Content = new StringContent("{\n  \"Email\": \"\",\n  \"Role\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"UnapplyCustomPermissions\": false,\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\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}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Email\": \"\",\n  \"Role\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"UnapplyCustomPermissions\": false,\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName"

	payload := strings.NewReader("{\n  \"Email\": \"\",\n  \"Role\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"UnapplyCustomPermissions\": false,\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	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))

}

PUT /baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 206

{
  "Email": "",
  "Role": "",
  "CustomPermissionsName": "",
  "UnapplyCustomPermissions": false,
  "ExternalLoginFederationProviderType": "",
  "CustomFederationProviderUrl": "",
  "ExternalLoginId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Email\": \"\",\n  \"Role\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"UnapplyCustomPermissions\": false,\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"Email\": \"\",\n  \"Role\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"UnapplyCustomPermissions\": false,\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\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  \"Email\": \"\",\n  \"Role\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"UnapplyCustomPermissions\": false,\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName")
  .header("content-type", "application/json")
  .body("{\n  \"Email\": \"\",\n  \"Role\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"UnapplyCustomPermissions\": false,\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Email: '',
  Role: '',
  CustomPermissionsName: '',
  UnapplyCustomPermissions: false,
  ExternalLoginFederationProviderType: '',
  CustomFederationProviderUrl: '',
  ExternalLoginId: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName',
  headers: {'content-type': 'application/json'},
  data: {
    Email: '',
    Role: '',
    CustomPermissionsName: '',
    UnapplyCustomPermissions: false,
    ExternalLoginFederationProviderType: '',
    CustomFederationProviderUrl: '',
    ExternalLoginId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Email":"","Role":"","CustomPermissionsName":"","UnapplyCustomPermissions":false,"ExternalLoginFederationProviderType":"","CustomFederationProviderUrl":"","ExternalLoginId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Email": "",\n  "Role": "",\n  "CustomPermissionsName": "",\n  "UnapplyCustomPermissions": false,\n  "ExternalLoginFederationProviderType": "",\n  "CustomFederationProviderUrl": "",\n  "ExternalLoginId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Email\": \"\",\n  \"Role\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"UnapplyCustomPermissions\": false,\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName',
  headers: {
    '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({
  Email: '',
  Role: '',
  CustomPermissionsName: '',
  UnapplyCustomPermissions: false,
  ExternalLoginFederationProviderType: '',
  CustomFederationProviderUrl: '',
  ExternalLoginId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName',
  headers: {'content-type': 'application/json'},
  body: {
    Email: '',
    Role: '',
    CustomPermissionsName: '',
    UnapplyCustomPermissions: false,
    ExternalLoginFederationProviderType: '',
    CustomFederationProviderUrl: '',
    ExternalLoginId: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Email: '',
  Role: '',
  CustomPermissionsName: '',
  UnapplyCustomPermissions: false,
  ExternalLoginFederationProviderType: '',
  CustomFederationProviderUrl: '',
  ExternalLoginId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName',
  headers: {'content-type': 'application/json'},
  data: {
    Email: '',
    Role: '',
    CustomPermissionsName: '',
    UnapplyCustomPermissions: false,
    ExternalLoginFederationProviderType: '',
    CustomFederationProviderUrl: '',
    ExternalLoginId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Email":"","Role":"","CustomPermissionsName":"","UnapplyCustomPermissions":false,"ExternalLoginFederationProviderType":"","CustomFederationProviderUrl":"","ExternalLoginId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Email": @"",
                              @"Role": @"",
                              @"CustomPermissionsName": @"",
                              @"UnapplyCustomPermissions": @NO,
                              @"ExternalLoginFederationProviderType": @"",
                              @"CustomFederationProviderUrl": @"",
                              @"ExternalLoginId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Email\": \"\",\n  \"Role\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"UnapplyCustomPermissions\": false,\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'Email' => '',
    'Role' => '',
    'CustomPermissionsName' => '',
    'UnapplyCustomPermissions' => null,
    'ExternalLoginFederationProviderType' => '',
    'CustomFederationProviderUrl' => '',
    'ExternalLoginId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName', [
  'body' => '{
  "Email": "",
  "Role": "",
  "CustomPermissionsName": "",
  "UnapplyCustomPermissions": false,
  "ExternalLoginFederationProviderType": "",
  "CustomFederationProviderUrl": "",
  "ExternalLoginId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Email' => '',
  'Role' => '',
  'CustomPermissionsName' => '',
  'UnapplyCustomPermissions' => null,
  'ExternalLoginFederationProviderType' => '',
  'CustomFederationProviderUrl' => '',
  'ExternalLoginId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Email' => '',
  'Role' => '',
  'CustomPermissionsName' => '',
  'UnapplyCustomPermissions' => null,
  'ExternalLoginFederationProviderType' => '',
  'CustomFederationProviderUrl' => '',
  'ExternalLoginId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Email": "",
  "Role": "",
  "CustomPermissionsName": "",
  "UnapplyCustomPermissions": false,
  "ExternalLoginFederationProviderType": "",
  "CustomFederationProviderUrl": "",
  "ExternalLoginId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Email": "",
  "Role": "",
  "CustomPermissionsName": "",
  "UnapplyCustomPermissions": false,
  "ExternalLoginFederationProviderType": "",
  "CustomFederationProviderUrl": "",
  "ExternalLoginId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Email\": \"\",\n  \"Role\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"UnapplyCustomPermissions\": false,\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName"

payload = {
    "Email": "",
    "Role": "",
    "CustomPermissionsName": "",
    "UnapplyCustomPermissions": False,
    "ExternalLoginFederationProviderType": "",
    "CustomFederationProviderUrl": "",
    "ExternalLoginId": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName"

payload <- "{\n  \"Email\": \"\",\n  \"Role\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"UnapplyCustomPermissions\": false,\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Email\": \"\",\n  \"Role\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"UnapplyCustomPermissions\": false,\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\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.put('/baseUrl/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName') do |req|
  req.body = "{\n  \"Email\": \"\",\n  \"Role\": \"\",\n  \"CustomPermissionsName\": \"\",\n  \"UnapplyCustomPermissions\": false,\n  \"ExternalLoginFederationProviderType\": \"\",\n  \"CustomFederationProviderUrl\": \"\",\n  \"ExternalLoginId\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName";

    let payload = json!({
        "Email": "",
        "Role": "",
        "CustomPermissionsName": "",
        "UnapplyCustomPermissions": false,
        "ExternalLoginFederationProviderType": "",
        "CustomFederationProviderUrl": "",
        "ExternalLoginId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName \
  --header 'content-type: application/json' \
  --data '{
  "Email": "",
  "Role": "",
  "CustomPermissionsName": "",
  "UnapplyCustomPermissions": false,
  "ExternalLoginFederationProviderType": "",
  "CustomFederationProviderUrl": "",
  "ExternalLoginId": ""
}'

echo '{
  "Email": "",
  "Role": "",
  "CustomPermissionsName": "",
  "UnapplyCustomPermissions": false,
  "ExternalLoginFederationProviderType": "",
  "CustomFederationProviderUrl": "",
  "ExternalLoginId": ""
}' |  \
  http PUT {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "Email": "",\n  "Role": "",\n  "CustomPermissionsName": "",\n  "UnapplyCustomPermissions": false,\n  "ExternalLoginFederationProviderType": "",\n  "CustomFederationProviderUrl": "",\n  "ExternalLoginId": ""\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Email": "",
  "Role": "",
  "CustomPermissionsName": "",
  "UnapplyCustomPermissions": false,
  "ExternalLoginFederationProviderType": "",
  "CustomFederationProviderUrl": "",
  "ExternalLoginId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/:AwsAccountId/namespaces/:Namespace/users/:UserName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

Amazon QuickSightv2018-04-01

Related APIs