AWS Resource Access Manager

POST AcceptResourceShareInvitation

{{baseUrl}}/acceptresourceshareinvitation

BODY json

{
  "resourceShareInvitationArn": "",
  "clientToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/acceptresourceshareinvitation");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/acceptresourceshareinvitation" {:content-type :json
                                                                          :form-params {:resourceShareInvitationArn ""
                                                                                        :clientToken ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/acceptresourceshareinvitation"

	payload := strings.NewReader("{\n  \"resourceShareInvitationArn\": \"\",\n  \"clientToken\": \"\"\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/acceptresourceshareinvitation HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 59

{
  "resourceShareInvitationArn": "",
  "clientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/acceptresourceshareinvitation")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"resourceShareInvitationArn\": \"\",\n  \"clientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/acceptresourceshareinvitation")
  .header("content-type", "application/json")
  .body("{\n  \"resourceShareInvitationArn\": \"\",\n  \"clientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  resourceShareInvitationArn: '',
  clientToken: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/acceptresourceshareinvitation',
  headers: {'content-type': 'application/json'},
  data: {resourceShareInvitationArn: '', clientToken: ''}
};

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

const url = '{{baseUrl}}/acceptresourceshareinvitation';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceShareInvitationArn":"","clientToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/acceptresourceshareinvitation',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "resourceShareInvitationArn": "",\n  "clientToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"resourceShareInvitationArn\": \"\",\n  \"clientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/acceptresourceshareinvitation")
  .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/acceptresourceshareinvitation',
  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({resourceShareInvitationArn: '', clientToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/acceptresourceshareinvitation',
  headers: {'content-type': 'application/json'},
  body: {resourceShareInvitationArn: '', clientToken: ''},
  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}}/acceptresourceshareinvitation');

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

req.type('json');
req.send({
  resourceShareInvitationArn: '',
  clientToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/acceptresourceshareinvitation',
  headers: {'content-type': 'application/json'},
  data: {resourceShareInvitationArn: '', clientToken: ''}
};

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

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

const url = '{{baseUrl}}/acceptresourceshareinvitation';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceShareInvitationArn":"","clientToken":""}'
};

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

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

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

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

 "{{baseUrl}}/acceptresourceshareinvitation",
  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([
    'resourceShareInvitationArn' => '',
    'clientToken' => ''
  ]),
  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}}/acceptresourceshareinvitation', [
  'body' => '{
  "resourceShareInvitationArn": "",
  "clientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/acceptresourceshareinvitation');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'resourceShareInvitationArn' => '',
  'clientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/acceptresourceshareinvitation');
$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}}/acceptresourceshareinvitation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceShareInvitationArn": "",
  "clientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/acceptresourceshareinvitation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceShareInvitationArn": "",
  "clientToken": ""
}'

import http.client

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

payload = "{\n  \"resourceShareInvitationArn\": \"\",\n  \"clientToken\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/acceptresourceshareinvitation"

payload = {
    "resourceShareInvitationArn": "",
    "clientToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/acceptresourceshareinvitation"

payload <- "{\n  \"resourceShareInvitationArn\": \"\",\n  \"clientToken\": \"\"\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}}/acceptresourceshareinvitation")

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  \"resourceShareInvitationArn\": \"\",\n  \"clientToken\": \"\"\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/acceptresourceshareinvitation') do |req|
  req.body = "{\n  \"resourceShareInvitationArn\": \"\",\n  \"clientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "resourceShareInvitationArn": "",
        "clientToken": ""
    });

    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}}/acceptresourceshareinvitation \
  --header 'content-type: application/json' \
  --data '{
  "resourceShareInvitationArn": "",
  "clientToken": ""
}'

echo '{
  "resourceShareInvitationArn": "",
  "clientToken": ""
}' |  \
  http POST {{baseUrl}}/acceptresourceshareinvitation \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "resourceShareInvitationArn": "",\n  "clientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/acceptresourceshareinvitation

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "resourceShareInvitationArn": "",
  "clientToken": ""
] as [String : Any]

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

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

{{baseUrl}}/associateresourceshare

BODY json

{
  "resourceShareArn": "",
  "resourceArns": [],
  "principals": [],
  "clientToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/associateresourceshare");

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  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/associateresourceshare" {:content-type :json
                                                                   :form-params {:resourceShareArn ""
                                                                                 :resourceArns []
                                                                                 :principals []
                                                                                 :clientToken ""}})

require "http/client"

url = "{{baseUrl}}/associateresourceshare"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\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}}/associateresourceshare"),
    Content = new StringContent("{\n  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\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}}/associateresourceshare");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/associateresourceshare"

	payload := strings.NewReader("{\n  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\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/associateresourceshare HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 91

{
  "resourceShareArn": "",
  "resourceArns": [],
  "principals": [],
  "clientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/associateresourceshare")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/associateresourceshare"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\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  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/associateresourceshare")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/associateresourceshare")
  .header("content-type", "application/json")
  .body("{\n  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  resourceShareArn: '',
  resourceArns: [],
  principals: [],
  clientToken: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/associateresourceshare',
  headers: {'content-type': 'application/json'},
  data: {resourceShareArn: '', resourceArns: [], principals: [], clientToken: ''}
};

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

const url = '{{baseUrl}}/associateresourceshare';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceShareArn":"","resourceArns":[],"principals":[],"clientToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/associateresourceshare',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "resourceShareArn": "",\n  "resourceArns": [],\n  "principals": [],\n  "clientToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/associateresourceshare")
  .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/associateresourceshare',
  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({resourceShareArn: '', resourceArns: [], principals: [], clientToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/associateresourceshare',
  headers: {'content-type': 'application/json'},
  body: {resourceShareArn: '', resourceArns: [], principals: [], clientToken: ''},
  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}}/associateresourceshare');

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

req.type('json');
req.send({
  resourceShareArn: '',
  resourceArns: [],
  principals: [],
  clientToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/associateresourceshare',
  headers: {'content-type': 'application/json'},
  data: {resourceShareArn: '', resourceArns: [], principals: [], clientToken: ''}
};

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

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

const url = '{{baseUrl}}/associateresourceshare';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceShareArn":"","resourceArns":[],"principals":[],"clientToken":""}'
};

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 = @{ @"resourceShareArn": @"",
                              @"resourceArns": @[  ],
                              @"principals": @[  ],
                              @"clientToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/associateresourceshare"]
                                                       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}}/associateresourceshare" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\n}" in

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

 "{{baseUrl}}/associateresourceshare",
  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([
    'resourceShareArn' => '',
    'resourceArns' => [
        
    ],
    'principals' => [
        
    ],
    'clientToken' => ''
  ]),
  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}}/associateresourceshare', [
  'body' => '{
  "resourceShareArn": "",
  "resourceArns": [],
  "principals": [],
  "clientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/associateresourceshare');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'resourceShareArn' => '',
  'resourceArns' => [
    
  ],
  'principals' => [
    
  ],
  'clientToken' => ''
]));

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

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

append(json_encode([
  'resourceShareArn' => '',
  'resourceArns' => [
    
  ],
  'principals' => [
    
  ],
  'clientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/associateresourceshare');
$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}}/associateresourceshare' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceShareArn": "",
  "resourceArns": [],
  "principals": [],
  "clientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/associateresourceshare' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceShareArn": "",
  "resourceArns": [],
  "principals": [],
  "clientToken": ""
}'

import http.client

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

payload = "{\n  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/associateresourceshare"

payload = {
    "resourceShareArn": "",
    "resourceArns": [],
    "principals": [],
    "clientToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/associateresourceshare"

payload <- "{\n  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\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}}/associateresourceshare")

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  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\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/associateresourceshare') do |req|
  req.body = "{\n  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "resourceShareArn": "",
        "resourceArns": (),
        "principals": (),
        "clientToken": ""
    });

    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}}/associateresourceshare \
  --header 'content-type: application/json' \
  --data '{
  "resourceShareArn": "",
  "resourceArns": [],
  "principals": [],
  "clientToken": ""
}'

echo '{
  "resourceShareArn": "",
  "resourceArns": [],
  "principals": [],
  "clientToken": ""
}' |  \
  http POST {{baseUrl}}/associateresourceshare \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "resourceShareArn": "",\n  "resourceArns": [],\n  "principals": [],\n  "clientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/associateresourceshare

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "resourceShareArn": "",
  "resourceArns": [],
  "principals": [],
  "clientToken": ""
] as [String : Any]

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

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

{{baseUrl}}/associateresourcesharepermission

BODY json

{
  "resourceShareArn": "",
  "permissionArn": "",
  "replace": false,
  "clientToken": "",
  "permissionVersion": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/associateresourcesharepermission");

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  \"resourceShareArn\": \"\",\n  \"permissionArn\": \"\",\n  \"replace\": false,\n  \"clientToken\": \"\",\n  \"permissionVersion\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/associateresourcesharepermission" {:content-type :json
                                                                             :form-params {:resourceShareArn ""
                                                                                           :permissionArn ""
                                                                                           :replace false
                                                                                           :clientToken ""
                                                                                           :permissionVersion 0}})

require "http/client"

url = "{{baseUrl}}/associateresourcesharepermission"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"resourceShareArn\": \"\",\n  \"permissionArn\": \"\",\n  \"replace\": false,\n  \"clientToken\": \"\",\n  \"permissionVersion\": 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}}/associateresourcesharepermission"),
    Content = new StringContent("{\n  \"resourceShareArn\": \"\",\n  \"permissionArn\": \"\",\n  \"replace\": false,\n  \"clientToken\": \"\",\n  \"permissionVersion\": 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}}/associateresourcesharepermission");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"resourceShareArn\": \"\",\n  \"permissionArn\": \"\",\n  \"replace\": false,\n  \"clientToken\": \"\",\n  \"permissionVersion\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/associateresourcesharepermission"

	payload := strings.NewReader("{\n  \"resourceShareArn\": \"\",\n  \"permissionArn\": \"\",\n  \"replace\": false,\n  \"clientToken\": \"\",\n  \"permissionVersion\": 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/associateresourcesharepermission HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 118

{
  "resourceShareArn": "",
  "permissionArn": "",
  "replace": false,
  "clientToken": "",
  "permissionVersion": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/associateresourcesharepermission")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"resourceShareArn\": \"\",\n  \"permissionArn\": \"\",\n  \"replace\": false,\n  \"clientToken\": \"\",\n  \"permissionVersion\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/associateresourcesharepermission"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"resourceShareArn\": \"\",\n  \"permissionArn\": \"\",\n  \"replace\": false,\n  \"clientToken\": \"\",\n  \"permissionVersion\": 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  \"resourceShareArn\": \"\",\n  \"permissionArn\": \"\",\n  \"replace\": false,\n  \"clientToken\": \"\",\n  \"permissionVersion\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/associateresourcesharepermission")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/associateresourcesharepermission")
  .header("content-type", "application/json")
  .body("{\n  \"resourceShareArn\": \"\",\n  \"permissionArn\": \"\",\n  \"replace\": false,\n  \"clientToken\": \"\",\n  \"permissionVersion\": 0\n}")
  .asString();

const data = JSON.stringify({
  resourceShareArn: '',
  permissionArn: '',
  replace: false,
  clientToken: '',
  permissionVersion: 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}}/associateresourcesharepermission');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/associateresourcesharepermission',
  headers: {'content-type': 'application/json'},
  data: {
    resourceShareArn: '',
    permissionArn: '',
    replace: false,
    clientToken: '',
    permissionVersion: 0
  }
};

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

const url = '{{baseUrl}}/associateresourcesharepermission';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceShareArn":"","permissionArn":"","replace":false,"clientToken":"","permissionVersion":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}}/associateresourcesharepermission',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "resourceShareArn": "",\n  "permissionArn": "",\n  "replace": false,\n  "clientToken": "",\n  "permissionVersion": 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  \"resourceShareArn\": \"\",\n  \"permissionArn\": \"\",\n  \"replace\": false,\n  \"clientToken\": \"\",\n  \"permissionVersion\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/associateresourcesharepermission")
  .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/associateresourcesharepermission',
  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({
  resourceShareArn: '',
  permissionArn: '',
  replace: false,
  clientToken: '',
  permissionVersion: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/associateresourcesharepermission',
  headers: {'content-type': 'application/json'},
  body: {
    resourceShareArn: '',
    permissionArn: '',
    replace: false,
    clientToken: '',
    permissionVersion: 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}}/associateresourcesharepermission');

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

req.type('json');
req.send({
  resourceShareArn: '',
  permissionArn: '',
  replace: false,
  clientToken: '',
  permissionVersion: 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}}/associateresourcesharepermission',
  headers: {'content-type': 'application/json'},
  data: {
    resourceShareArn: '',
    permissionArn: '',
    replace: false,
    clientToken: '',
    permissionVersion: 0
  }
};

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

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

const url = '{{baseUrl}}/associateresourcesharepermission';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceShareArn":"","permissionArn":"","replace":false,"clientToken":"","permissionVersion":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 = @{ @"resourceShareArn": @"",
                              @"permissionArn": @"",
                              @"replace": @NO,
                              @"clientToken": @"",
                              @"permissionVersion": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/associateresourcesharepermission"]
                                                       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}}/associateresourcesharepermission" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"resourceShareArn\": \"\",\n  \"permissionArn\": \"\",\n  \"replace\": false,\n  \"clientToken\": \"\",\n  \"permissionVersion\": 0\n}" in

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

 "{{baseUrl}}/associateresourcesharepermission",
  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([
    'resourceShareArn' => '',
    'permissionArn' => '',
    'replace' => null,
    'clientToken' => '',
    'permissionVersion' => 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}}/associateresourcesharepermission', [
  'body' => '{
  "resourceShareArn": "",
  "permissionArn": "",
  "replace": false,
  "clientToken": "",
  "permissionVersion": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/associateresourcesharepermission');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'resourceShareArn' => '',
  'permissionArn' => '',
  'replace' => null,
  'clientToken' => '',
  'permissionVersion' => 0
]));

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

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

append(json_encode([
  'resourceShareArn' => '',
  'permissionArn' => '',
  'replace' => null,
  'clientToken' => '',
  'permissionVersion' => 0
]));
$request->setRequestUrl('{{baseUrl}}/associateresourcesharepermission');
$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}}/associateresourcesharepermission' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceShareArn": "",
  "permissionArn": "",
  "replace": false,
  "clientToken": "",
  "permissionVersion": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/associateresourcesharepermission' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceShareArn": "",
  "permissionArn": "",
  "replace": false,
  "clientToken": "",
  "permissionVersion": 0
}'

import http.client

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

payload = "{\n  \"resourceShareArn\": \"\",\n  \"permissionArn\": \"\",\n  \"replace\": false,\n  \"clientToken\": \"\",\n  \"permissionVersion\": 0\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/associateresourcesharepermission"

payload = {
    "resourceShareArn": "",
    "permissionArn": "",
    "replace": False,
    "clientToken": "",
    "permissionVersion": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/associateresourcesharepermission"

payload <- "{\n  \"resourceShareArn\": \"\",\n  \"permissionArn\": \"\",\n  \"replace\": false,\n  \"clientToken\": \"\",\n  \"permissionVersion\": 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}}/associateresourcesharepermission")

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  \"resourceShareArn\": \"\",\n  \"permissionArn\": \"\",\n  \"replace\": false,\n  \"clientToken\": \"\",\n  \"permissionVersion\": 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/associateresourcesharepermission') do |req|
  req.body = "{\n  \"resourceShareArn\": \"\",\n  \"permissionArn\": \"\",\n  \"replace\": false,\n  \"clientToken\": \"\",\n  \"permissionVersion\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "resourceShareArn": "",
        "permissionArn": "",
        "replace": false,
        "clientToken": "",
        "permissionVersion": 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}}/associateresourcesharepermission \
  --header 'content-type: application/json' \
  --data '{
  "resourceShareArn": "",
  "permissionArn": "",
  "replace": false,
  "clientToken": "",
  "permissionVersion": 0
}'

echo '{
  "resourceShareArn": "",
  "permissionArn": "",
  "replace": false,
  "clientToken": "",
  "permissionVersion": 0
}' |  \
  http POST {{baseUrl}}/associateresourcesharepermission \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "resourceShareArn": "",\n  "permissionArn": "",\n  "replace": false,\n  "clientToken": "",\n  "permissionVersion": 0\n}' \
  --output-document \
  - {{baseUrl}}/associateresourcesharepermission

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "resourceShareArn": "",
  "permissionArn": "",
  "replace": false,
  "clientToken": "",
  "permissionVersion": 0
] as [String : Any]

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

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

{{baseUrl}}/createpermission

BODY json

{
  "name": "",
  "resourceType": "",
  "policyTemplate": "",
  "clientToken": "",
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/createpermission");

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  \"resourceType\": \"\",\n  \"policyTemplate\": \"\",\n  \"clientToken\": \"\",\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}}/createpermission" {:content-type :json
                                                             :form-params {:name ""
                                                                           :resourceType ""
                                                                           :policyTemplate ""
                                                                           :clientToken ""
                                                                           :tags [{:key ""
                                                                                   :value ""}]}})

require "http/client"

url = "{{baseUrl}}/createpermission"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"resourceType\": \"\",\n  \"policyTemplate\": \"\",\n  \"clientToken\": \"\",\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}}/createpermission"),
    Content = new StringContent("{\n  \"name\": \"\",\n  \"resourceType\": \"\",\n  \"policyTemplate\": \"\",\n  \"clientToken\": \"\",\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}}/createpermission");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"resourceType\": \"\",\n  \"policyTemplate\": \"\",\n  \"clientToken\": \"\",\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}}/createpermission"

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"resourceType\": \"\",\n  \"policyTemplate\": \"\",\n  \"clientToken\": \"\",\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/createpermission HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 147

{
  "name": "",
  "resourceType": "",
  "policyTemplate": "",
  "clientToken": "",
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/createpermission")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"resourceType\": \"\",\n  \"policyTemplate\": \"\",\n  \"clientToken\": \"\",\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}}/createpermission"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"resourceType\": \"\",\n  \"policyTemplate\": \"\",\n  \"clientToken\": \"\",\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  \"resourceType\": \"\",\n  \"policyTemplate\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/createpermission")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/createpermission")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"resourceType\": \"\",\n  \"policyTemplate\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  resourceType: '',
  policyTemplate: '',
  clientToken: '',
  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}}/createpermission');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/createpermission',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    resourceType: '',
    policyTemplate: '',
    clientToken: '',
    tags: [{key: '', value: ''}]
  }
};

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

const url = '{{baseUrl}}/createpermission';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","resourceType":"","policyTemplate":"","clientToken":"","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}}/createpermission',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "resourceType": "",\n  "policyTemplate": "",\n  "clientToken": "",\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  \"resourceType\": \"\",\n  \"policyTemplate\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/createpermission")
  .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/createpermission',
  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: '',
  resourceType: '',
  policyTemplate: '',
  clientToken: '',
  tags: [{key: '', value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/createpermission',
  headers: {'content-type': 'application/json'},
  body: {
    name: '',
    resourceType: '',
    policyTemplate: '',
    clientToken: '',
    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}}/createpermission');

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

req.type('json');
req.send({
  name: '',
  resourceType: '',
  policyTemplate: '',
  clientToken: '',
  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}}/createpermission',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    resourceType: '',
    policyTemplate: '',
    clientToken: '',
    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}}/createpermission';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","resourceType":"","policyTemplate":"","clientToken":"","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": @"",
                              @"resourceType": @"",
                              @"policyTemplate": @"",
                              @"clientToken": @"",
                              @"tags": @[ @{ @"key": @"", @"value": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/createpermission"]
                                                       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}}/createpermission" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"resourceType\": \"\",\n  \"policyTemplate\": \"\",\n  \"clientToken\": \"\",\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}}/createpermission",
  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' => '',
    'resourceType' => '',
    'policyTemplate' => '',
    'clientToken' => '',
    '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}}/createpermission', [
  'body' => '{
  "name": "",
  "resourceType": "",
  "policyTemplate": "",
  "clientToken": "",
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/createpermission');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'resourceType' => '',
  'policyTemplate' => '',
  'clientToken' => '',
  'tags' => [
    [
        'key' => '',
        'value' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'name' => '',
  'resourceType' => '',
  'policyTemplate' => '',
  'clientToken' => '',
  'tags' => [
    [
        'key' => '',
        'value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/createpermission');
$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}}/createpermission' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "resourceType": "",
  "policyTemplate": "",
  "clientToken": "",
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/createpermission' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "resourceType": "",
  "policyTemplate": "",
  "clientToken": "",
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"name\": \"\",\n  \"resourceType\": \"\",\n  \"policyTemplate\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/createpermission"

payload = {
    "name": "",
    "resourceType": "",
    "policyTemplate": "",
    "clientToken": "",
    "tags": [
        {
            "key": "",
            "value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/createpermission"

payload <- "{\n  \"name\": \"\",\n  \"resourceType\": \"\",\n  \"policyTemplate\": \"\",\n  \"clientToken\": \"\",\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}}/createpermission")

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  \"resourceType\": \"\",\n  \"policyTemplate\": \"\",\n  \"clientToken\": \"\",\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/createpermission') do |req|
  req.body = "{\n  \"name\": \"\",\n  \"resourceType\": \"\",\n  \"policyTemplate\": \"\",\n  \"clientToken\": \"\",\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}}/createpermission";

    let payload = json!({
        "name": "",
        "resourceType": "",
        "policyTemplate": "",
        "clientToken": "",
        "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}}/createpermission \
  --header 'content-type: application/json' \
  --data '{
  "name": "",
  "resourceType": "",
  "policyTemplate": "",
  "clientToken": "",
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ]
}'

echo '{
  "name": "",
  "resourceType": "",
  "policyTemplate": "",
  "clientToken": "",
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/createpermission \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "resourceType": "",\n  "policyTemplate": "",\n  "clientToken": "",\n  "tags": [\n    {\n      "key": "",\n      "value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/createpermission

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "name": "",
  "resourceType": "",
  "policyTemplate": "",
  "clientToken": "",
  "tags": [
    [
      "key": "",
      "value": ""
    ]
  ]
] as [String : Any]

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

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

{{baseUrl}}/createpermissionversion

BODY json

{
  "permissionArn": "",
  "policyTemplate": "",
  "clientToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/createpermissionversion");

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  \"permissionArn\": \"\",\n  \"policyTemplate\": \"\",\n  \"clientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/createpermissionversion" {:content-type :json
                                                                    :form-params {:permissionArn ""
                                                                                  :policyTemplate ""
                                                                                  :clientToken ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/createpermissionversion"

	payload := strings.NewReader("{\n  \"permissionArn\": \"\",\n  \"policyTemplate\": \"\",\n  \"clientToken\": \"\"\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/createpermissionversion HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 70

{
  "permissionArn": "",
  "policyTemplate": "",
  "clientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/createpermissionversion")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"permissionArn\": \"\",\n  \"policyTemplate\": \"\",\n  \"clientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/createpermissionversion")
  .header("content-type", "application/json")
  .body("{\n  \"permissionArn\": \"\",\n  \"policyTemplate\": \"\",\n  \"clientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  permissionArn: '',
  policyTemplate: '',
  clientToken: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/createpermissionversion',
  headers: {'content-type': 'application/json'},
  data: {permissionArn: '', policyTemplate: '', clientToken: ''}
};

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

const url = '{{baseUrl}}/createpermissionversion';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"permissionArn":"","policyTemplate":"","clientToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/createpermissionversion',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "permissionArn": "",\n  "policyTemplate": "",\n  "clientToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"permissionArn\": \"\",\n  \"policyTemplate\": \"\",\n  \"clientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/createpermissionversion")
  .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/createpermissionversion',
  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({permissionArn: '', policyTemplate: '', clientToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/createpermissionversion',
  headers: {'content-type': 'application/json'},
  body: {permissionArn: '', policyTemplate: '', clientToken: ''},
  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}}/createpermissionversion');

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

req.type('json');
req.send({
  permissionArn: '',
  policyTemplate: '',
  clientToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/createpermissionversion',
  headers: {'content-type': 'application/json'},
  data: {permissionArn: '', policyTemplate: '', clientToken: ''}
};

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

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

const url = '{{baseUrl}}/createpermissionversion';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"permissionArn":"","policyTemplate":"","clientToken":""}'
};

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 = @{ @"permissionArn": @"",
                              @"policyTemplate": @"",
                              @"clientToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/createpermissionversion"]
                                                       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}}/createpermissionversion" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"permissionArn\": \"\",\n  \"policyTemplate\": \"\",\n  \"clientToken\": \"\"\n}" in

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

 "{{baseUrl}}/createpermissionversion",
  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([
    'permissionArn' => '',
    'policyTemplate' => '',
    'clientToken' => ''
  ]),
  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}}/createpermissionversion', [
  'body' => '{
  "permissionArn": "",
  "policyTemplate": "",
  "clientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/createpermissionversion');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'permissionArn' => '',
  'policyTemplate' => '',
  'clientToken' => ''
]));

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

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

append(json_encode([
  'permissionArn' => '',
  'policyTemplate' => '',
  'clientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/createpermissionversion');
$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}}/createpermissionversion' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "permissionArn": "",
  "policyTemplate": "",
  "clientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/createpermissionversion' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "permissionArn": "",
  "policyTemplate": "",
  "clientToken": ""
}'

import http.client

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

payload = "{\n  \"permissionArn\": \"\",\n  \"policyTemplate\": \"\",\n  \"clientToken\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/createpermissionversion"

payload = {
    "permissionArn": "",
    "policyTemplate": "",
    "clientToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/createpermissionversion"

payload <- "{\n  \"permissionArn\": \"\",\n  \"policyTemplate\": \"\",\n  \"clientToken\": \"\"\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}}/createpermissionversion")

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  \"permissionArn\": \"\",\n  \"policyTemplate\": \"\",\n  \"clientToken\": \"\"\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/createpermissionversion') do |req|
  req.body = "{\n  \"permissionArn\": \"\",\n  \"policyTemplate\": \"\",\n  \"clientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "permissionArn": "",
        "policyTemplate": "",
        "clientToken": ""
    });

    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}}/createpermissionversion \
  --header 'content-type: application/json' \
  --data '{
  "permissionArn": "",
  "policyTemplate": "",
  "clientToken": ""
}'

echo '{
  "permissionArn": "",
  "policyTemplate": "",
  "clientToken": ""
}' |  \
  http POST {{baseUrl}}/createpermissionversion \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "permissionArn": "",\n  "policyTemplate": "",\n  "clientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/createpermissionversion

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "permissionArn": "",
  "policyTemplate": "",
  "clientToken": ""
] as [String : Any]

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

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

{{baseUrl}}/createresourceshare

BODY json

{
  "name": "",
  "resourceArns": [],
  "principals": [],
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ],
  "allowExternalPrincipals": false,
  "clientToken": "",
  "permissionArns": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/createresourceshare");

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  \"resourceArns\": [],\n  \"principals\": [],\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\",\n  \"permissionArns\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/createresourceshare" {:content-type :json
                                                                :form-params {:name ""
                                                                              :resourceArns []
                                                                              :principals []
                                                                              :tags [{:key ""
                                                                                      :value ""}]
                                                                              :allowExternalPrincipals false
                                                                              :clientToken ""
                                                                              :permissionArns []}})

require "http/client"

url = "{{baseUrl}}/createresourceshare"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\",\n  \"permissionArns\": []\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}}/createresourceshare"),
    Content = new StringContent("{\n  \"name\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\",\n  \"permissionArns\": []\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}}/createresourceshare");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\",\n  \"permissionArns\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/createresourceshare"

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\",\n  \"permissionArns\": []\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/createresourceshare HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 203

{
  "name": "",
  "resourceArns": [],
  "principals": [],
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ],
  "allowExternalPrincipals": false,
  "clientToken": "",
  "permissionArns": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/createresourceshare")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\",\n  \"permissionArns\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/createresourceshare"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\",\n  \"permissionArns\": []\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  \"resourceArns\": [],\n  \"principals\": [],\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\",\n  \"permissionArns\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/createresourceshare")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/createresourceshare")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\",\n  \"permissionArns\": []\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  resourceArns: [],
  principals: [],
  tags: [
    {
      key: '',
      value: ''
    }
  ],
  allowExternalPrincipals: false,
  clientToken: '',
  permissionArns: []
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/createresourceshare',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    resourceArns: [],
    principals: [],
    tags: [{key: '', value: ''}],
    allowExternalPrincipals: false,
    clientToken: '',
    permissionArns: []
  }
};

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

const url = '{{baseUrl}}/createresourceshare';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","resourceArns":[],"principals":[],"tags":[{"key":"","value":""}],"allowExternalPrincipals":false,"clientToken":"","permissionArns":[]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/createresourceshare',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "resourceArns": [],\n  "principals": [],\n  "tags": [\n    {\n      "key": "",\n      "value": ""\n    }\n  ],\n  "allowExternalPrincipals": false,\n  "clientToken": "",\n  "permissionArns": []\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  \"resourceArns\": [],\n  \"principals\": [],\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\",\n  \"permissionArns\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/createresourceshare")
  .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/createresourceshare',
  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: '',
  resourceArns: [],
  principals: [],
  tags: [{key: '', value: ''}],
  allowExternalPrincipals: false,
  clientToken: '',
  permissionArns: []
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/createresourceshare',
  headers: {'content-type': 'application/json'},
  body: {
    name: '',
    resourceArns: [],
    principals: [],
    tags: [{key: '', value: ''}],
    allowExternalPrincipals: false,
    clientToken: '',
    permissionArns: []
  },
  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}}/createresourceshare');

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

req.type('json');
req.send({
  name: '',
  resourceArns: [],
  principals: [],
  tags: [
    {
      key: '',
      value: ''
    }
  ],
  allowExternalPrincipals: false,
  clientToken: '',
  permissionArns: []
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/createresourceshare',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    resourceArns: [],
    principals: [],
    tags: [{key: '', value: ''}],
    allowExternalPrincipals: false,
    clientToken: '',
    permissionArns: []
  }
};

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

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

const url = '{{baseUrl}}/createresourceshare';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","resourceArns":[],"principals":[],"tags":[{"key":"","value":""}],"allowExternalPrincipals":false,"clientToken":"","permissionArns":[]}'
};

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": @"",
                              @"resourceArns": @[  ],
                              @"principals": @[  ],
                              @"tags": @[ @{ @"key": @"", @"value": @"" } ],
                              @"allowExternalPrincipals": @NO,
                              @"clientToken": @"",
                              @"permissionArns": @[  ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/createresourceshare"]
                                                       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}}/createresourceshare" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\",\n  \"permissionArns\": []\n}" in

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

 "{{baseUrl}}/createresourceshare",
  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' => '',
    'resourceArns' => [
        
    ],
    'principals' => [
        
    ],
    'tags' => [
        [
                'key' => '',
                'value' => ''
        ]
    ],
    'allowExternalPrincipals' => null,
    'clientToken' => '',
    'permissionArns' => [
        
    ]
  ]),
  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}}/createresourceshare', [
  'body' => '{
  "name": "",
  "resourceArns": [],
  "principals": [],
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ],
  "allowExternalPrincipals": false,
  "clientToken": "",
  "permissionArns": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/createresourceshare');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'resourceArns' => [
    
  ],
  'principals' => [
    
  ],
  'tags' => [
    [
        'key' => '',
        'value' => ''
    ]
  ],
  'allowExternalPrincipals' => null,
  'clientToken' => '',
  'permissionArns' => [
    
  ]
]));

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

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

append(json_encode([
  'name' => '',
  'resourceArns' => [
    
  ],
  'principals' => [
    
  ],
  'tags' => [
    [
        'key' => '',
        'value' => ''
    ]
  ],
  'allowExternalPrincipals' => null,
  'clientToken' => '',
  'permissionArns' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/createresourceshare');
$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}}/createresourceshare' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "resourceArns": [],
  "principals": [],
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ],
  "allowExternalPrincipals": false,
  "clientToken": "",
  "permissionArns": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/createresourceshare' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "resourceArns": [],
  "principals": [],
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ],
  "allowExternalPrincipals": false,
  "clientToken": "",
  "permissionArns": []
}'

import http.client

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

payload = "{\n  \"name\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\",\n  \"permissionArns\": []\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/createresourceshare"

payload = {
    "name": "",
    "resourceArns": [],
    "principals": [],
    "tags": [
        {
            "key": "",
            "value": ""
        }
    ],
    "allowExternalPrincipals": False,
    "clientToken": "",
    "permissionArns": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/createresourceshare"

payload <- "{\n  \"name\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\",\n  \"permissionArns\": []\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}}/createresourceshare")

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  \"resourceArns\": [],\n  \"principals\": [],\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\",\n  \"permissionArns\": []\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/createresourceshare') do |req|
  req.body = "{\n  \"name\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\",\n  \"permissionArns\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "name": "",
        "resourceArns": (),
        "principals": (),
        "tags": (
            json!({
                "key": "",
                "value": ""
            })
        ),
        "allowExternalPrincipals": false,
        "clientToken": "",
        "permissionArns": ()
    });

    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}}/createresourceshare \
  --header 'content-type: application/json' \
  --data '{
  "name": "",
  "resourceArns": [],
  "principals": [],
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ],
  "allowExternalPrincipals": false,
  "clientToken": "",
  "permissionArns": []
}'

echo '{
  "name": "",
  "resourceArns": [],
  "principals": [],
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ],
  "allowExternalPrincipals": false,
  "clientToken": "",
  "permissionArns": []
}' |  \
  http POST {{baseUrl}}/createresourceshare \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "resourceArns": [],\n  "principals": [],\n  "tags": [\n    {\n      "key": "",\n      "value": ""\n    }\n  ],\n  "allowExternalPrincipals": false,\n  "clientToken": "",\n  "permissionArns": []\n}' \
  --output-document \
  - {{baseUrl}}/createresourceshare

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "name": "",
  "resourceArns": [],
  "principals": [],
  "tags": [
    [
      "key": "",
      "value": ""
    ]
  ],
  "allowExternalPrincipals": false,
  "clientToken": "",
  "permissionArns": []
] as [String : Any]

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

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

{{baseUrl}}/deletepermission#permissionArn

QUERY PARAMS

permissionArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/deletepermission?permissionArn=#permissionArn");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/deletepermission#permissionArn" {:query-params {:permissionArn ""}})

require "http/client"

url = "{{baseUrl}}/deletepermission?permissionArn=#permissionArn"

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}}/deletepermission?permissionArn=#permissionArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/deletepermission?permissionArn=#permissionArn");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/deletepermission?permissionArn=#permissionArn"

	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/deletepermission?permissionArn= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/deletepermission?permissionArn=#permissionArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/deletepermission?permissionArn=#permissionArn"))
    .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}}/deletepermission?permissionArn=#permissionArn")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/deletepermission?permissionArn=#permissionArn")
  .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}}/deletepermission?permissionArn=#permissionArn');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/deletepermission#permissionArn',
  params: {permissionArn: ''}
};

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

const url = '{{baseUrl}}/deletepermission?permissionArn=#permissionArn';
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}}/deletepermission?permissionArn=#permissionArn',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/deletepermission?permissionArn=#permissionArn")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/deletepermission?permissionArn=',
  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}}/deletepermission#permissionArn',
  qs: {permissionArn: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/deletepermission#permissionArn');

req.query({
  permissionArn: ''
});

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}}/deletepermission#permissionArn',
  params: {permissionArn: ''}
};

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

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

const url = '{{baseUrl}}/deletepermission?permissionArn=#permissionArn';
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}}/deletepermission?permissionArn=#permissionArn"]
                                                       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}}/deletepermission?permissionArn=#permissionArn" in

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

 "{{baseUrl}}/deletepermission?permissionArn=#permissionArn",
  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}}/deletepermission?permissionArn=#permissionArn');

echo $response->getBody();

setUrl('{{baseUrl}}/deletepermission#permissionArn');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'permissionArn' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/deletepermission#permissionArn');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'permissionArn' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/deletepermission?permissionArn=#permissionArn' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/deletepermission?permissionArn=#permissionArn' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/deletepermission?permissionArn=")

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

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

import requests

url = "{{baseUrl}}/deletepermission#permissionArn"

querystring = {"permissionArn":""}

response = requests.delete(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/deletepermission#permissionArn"

queryString <- list(permissionArn = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/deletepermission?permissionArn=#permissionArn")

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/deletepermission') do |req|
  req.params['permissionArn'] = ''
end

puts response.status
puts response.body

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

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

    let querystring = [
        ("permissionArn", ""),
    ];

    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}}/deletepermission?permissionArn=#permissionArn'

http DELETE '{{baseUrl}}/deletepermission?permissionArn=#permissionArn'

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/deletepermission?permissionArn=#permissionArn'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/deletepermission?permissionArn=#permissionArn")! 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 DeletePermissionVersion

{{baseUrl}}/deletepermissionversion#permissionArn&permissionVersion

QUERY PARAMS

permissionArn

permissionVersion

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/deletepermissionversion?permissionArn=&permissionVersion=#permissionArn&permissionVersion");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/deletepermissionversion#permissionArn&permissionVersion" {:query-params {:permissionArn ""
                                                                                                                     :permissionVersion ""}})

require "http/client"

url = "{{baseUrl}}/deletepermissionversion?permissionArn=&permissionVersion=#permissionArn&permissionVersion"

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}}/deletepermissionversion?permissionArn=&permissionVersion=#permissionArn&permissionVersion"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/deletepermissionversion?permissionArn=&permissionVersion=#permissionArn&permissionVersion");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/deletepermissionversion?permissionArn=&permissionVersion=#permissionArn&permissionVersion"

	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/deletepermissionversion?permissionArn=&permissionVersion= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/deletepermissionversion?permissionArn=&permissionVersion=#permissionArn&permissionVersion")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/deletepermissionversion?permissionArn=&permissionVersion=#permissionArn&permissionVersion"))
    .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}}/deletepermissionversion?permissionArn=&permissionVersion=#permissionArn&permissionVersion")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/deletepermissionversion?permissionArn=&permissionVersion=#permissionArn&permissionVersion")
  .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}}/deletepermissionversion?permissionArn=&permissionVersion=#permissionArn&permissionVersion');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/deletepermissionversion#permissionArn&permissionVersion',
  params: {permissionArn: '', permissionVersion: ''}
};

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

const url = '{{baseUrl}}/deletepermissionversion?permissionArn=&permissionVersion=#permissionArn&permissionVersion';
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}}/deletepermissionversion?permissionArn=&permissionVersion=#permissionArn&permissionVersion',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/deletepermissionversion?permissionArn=&permissionVersion=#permissionArn&permissionVersion")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/deletepermissionversion?permissionArn=&permissionVersion=',
  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}}/deletepermissionversion#permissionArn&permissionVersion',
  qs: {permissionArn: '', permissionVersion: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/deletepermissionversion#permissionArn&permissionVersion');

req.query({
  permissionArn: '',
  permissionVersion: ''
});

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}}/deletepermissionversion#permissionArn&permissionVersion',
  params: {permissionArn: '', permissionVersion: ''}
};

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

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

const url = '{{baseUrl}}/deletepermissionversion?permissionArn=&permissionVersion=#permissionArn&permissionVersion';
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}}/deletepermissionversion?permissionArn=&permissionVersion=#permissionArn&permissionVersion"]
                                                       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}}/deletepermissionversion?permissionArn=&permissionVersion=#permissionArn&permissionVersion" in

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

 "{{baseUrl}}/deletepermissionversion?permissionArn=&permissionVersion=#permissionArn&permissionVersion",
  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}}/deletepermissionversion?permissionArn=&permissionVersion=#permissionArn&permissionVersion');

echo $response->getBody();

setUrl('{{baseUrl}}/deletepermissionversion#permissionArn&permissionVersion');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'permissionArn' => '',
  'permissionVersion' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/deletepermissionversion#permissionArn&permissionVersion');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'permissionArn' => '',
  'permissionVersion' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/deletepermissionversion?permissionArn=&permissionVersion=#permissionArn&permissionVersion' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/deletepermissionversion?permissionArn=&permissionVersion=#permissionArn&permissionVersion' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/deletepermissionversion?permissionArn=&permissionVersion=")

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

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

import requests

url = "{{baseUrl}}/deletepermissionversion#permissionArn&permissionVersion"

querystring = {"permissionArn":"","permissionVersion":""}

response = requests.delete(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/deletepermissionversion#permissionArn&permissionVersion"

queryString <- list(
  permissionArn = "",
  permissionVersion = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/deletepermissionversion?permissionArn=&permissionVersion=#permissionArn&permissionVersion")

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/deletepermissionversion') do |req|
  req.params['permissionArn'] = ''
  req.params['permissionVersion'] = ''
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/deletepermissionversion#permissionArn&permissionVersion";

    let querystring = [
        ("permissionArn", ""),
        ("permissionVersion", ""),
    ];

    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}}/deletepermissionversion?permissionArn=&permissionVersion=#permissionArn&permissionVersion'

http DELETE '{{baseUrl}}/deletepermissionversion?permissionArn=&permissionVersion=#permissionArn&permissionVersion'

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/deletepermissionversion?permissionArn=&permissionVersion=#permissionArn&permissionVersion'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/deletepermissionversion?permissionArn=&permissionVersion=#permissionArn&permissionVersion")! 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 DeleteResourceShare

{{baseUrl}}/deleteresourceshare#resourceShareArn

QUERY PARAMS

resourceShareArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/deleteresourceshare?resourceShareArn=#resourceShareArn");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/deleteresourceshare#resourceShareArn" {:query-params {:resourceShareArn ""}})

require "http/client"

url = "{{baseUrl}}/deleteresourceshare?resourceShareArn=#resourceShareArn"

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}}/deleteresourceshare?resourceShareArn=#resourceShareArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/deleteresourceshare?resourceShareArn=#resourceShareArn");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/deleteresourceshare?resourceShareArn=#resourceShareArn"

	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/deleteresourceshare?resourceShareArn= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/deleteresourceshare?resourceShareArn=#resourceShareArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/deleteresourceshare?resourceShareArn=#resourceShareArn"))
    .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}}/deleteresourceshare?resourceShareArn=#resourceShareArn")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/deleteresourceshare?resourceShareArn=#resourceShareArn")
  .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}}/deleteresourceshare?resourceShareArn=#resourceShareArn');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/deleteresourceshare#resourceShareArn',
  params: {resourceShareArn: ''}
};

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

const url = '{{baseUrl}}/deleteresourceshare?resourceShareArn=#resourceShareArn';
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}}/deleteresourceshare?resourceShareArn=#resourceShareArn',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/deleteresourceshare?resourceShareArn=#resourceShareArn")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/deleteresourceshare?resourceShareArn=',
  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}}/deleteresourceshare#resourceShareArn',
  qs: {resourceShareArn: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/deleteresourceshare#resourceShareArn');

req.query({
  resourceShareArn: ''
});

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}}/deleteresourceshare#resourceShareArn',
  params: {resourceShareArn: ''}
};

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

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

const url = '{{baseUrl}}/deleteresourceshare?resourceShareArn=#resourceShareArn';
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}}/deleteresourceshare?resourceShareArn=#resourceShareArn"]
                                                       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}}/deleteresourceshare?resourceShareArn=#resourceShareArn" in

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

 "{{baseUrl}}/deleteresourceshare?resourceShareArn=#resourceShareArn",
  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}}/deleteresourceshare?resourceShareArn=#resourceShareArn');

echo $response->getBody();

setUrl('{{baseUrl}}/deleteresourceshare#resourceShareArn');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'resourceShareArn' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/deleteresourceshare#resourceShareArn');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'resourceShareArn' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/deleteresourceshare?resourceShareArn=#resourceShareArn' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/deleteresourceshare?resourceShareArn=#resourceShareArn' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/deleteresourceshare?resourceShareArn=")

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

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

import requests

url = "{{baseUrl}}/deleteresourceshare#resourceShareArn"

querystring = {"resourceShareArn":""}

response = requests.delete(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/deleteresourceshare#resourceShareArn"

queryString <- list(resourceShareArn = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/deleteresourceshare?resourceShareArn=#resourceShareArn")

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/deleteresourceshare') do |req|
  req.params['resourceShareArn'] = ''
end

puts response.status
puts response.body

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

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

    let querystring = [
        ("resourceShareArn", ""),
    ];

    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}}/deleteresourceshare?resourceShareArn=#resourceShareArn'

http DELETE '{{baseUrl}}/deleteresourceshare?resourceShareArn=#resourceShareArn'

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/deleteresourceshare?resourceShareArn=#resourceShareArn'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/deleteresourceshare?resourceShareArn=#resourceShareArn")! 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 DisassociateResourceShare

{{baseUrl}}/disassociateresourceshare

BODY json

{
  "resourceShareArn": "",
  "resourceArns": [],
  "principals": [],
  "clientToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/disassociateresourceshare");

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  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/disassociateresourceshare" {:content-type :json
                                                                      :form-params {:resourceShareArn ""
                                                                                    :resourceArns []
                                                                                    :principals []
                                                                                    :clientToken ""}})

require "http/client"

url = "{{baseUrl}}/disassociateresourceshare"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\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}}/disassociateresourceshare"),
    Content = new StringContent("{\n  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\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}}/disassociateresourceshare");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/disassociateresourceshare"

	payload := strings.NewReader("{\n  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\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/disassociateresourceshare HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 91

{
  "resourceShareArn": "",
  "resourceArns": [],
  "principals": [],
  "clientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/disassociateresourceshare")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/disassociateresourceshare"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\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  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/disassociateresourceshare")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/disassociateresourceshare")
  .header("content-type", "application/json")
  .body("{\n  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  resourceShareArn: '',
  resourceArns: [],
  principals: [],
  clientToken: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/disassociateresourceshare',
  headers: {'content-type': 'application/json'},
  data: {resourceShareArn: '', resourceArns: [], principals: [], clientToken: ''}
};

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

const url = '{{baseUrl}}/disassociateresourceshare';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceShareArn":"","resourceArns":[],"principals":[],"clientToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/disassociateresourceshare',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "resourceShareArn": "",\n  "resourceArns": [],\n  "principals": [],\n  "clientToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/disassociateresourceshare")
  .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/disassociateresourceshare',
  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({resourceShareArn: '', resourceArns: [], principals: [], clientToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/disassociateresourceshare',
  headers: {'content-type': 'application/json'},
  body: {resourceShareArn: '', resourceArns: [], principals: [], clientToken: ''},
  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}}/disassociateresourceshare');

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

req.type('json');
req.send({
  resourceShareArn: '',
  resourceArns: [],
  principals: [],
  clientToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/disassociateresourceshare',
  headers: {'content-type': 'application/json'},
  data: {resourceShareArn: '', resourceArns: [], principals: [], clientToken: ''}
};

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

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

const url = '{{baseUrl}}/disassociateresourceshare';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceShareArn":"","resourceArns":[],"principals":[],"clientToken":""}'
};

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 = @{ @"resourceShareArn": @"",
                              @"resourceArns": @[  ],
                              @"principals": @[  ],
                              @"clientToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/disassociateresourceshare"]
                                                       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}}/disassociateresourceshare" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\n}" in

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

 "{{baseUrl}}/disassociateresourceshare",
  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([
    'resourceShareArn' => '',
    'resourceArns' => [
        
    ],
    'principals' => [
        
    ],
    'clientToken' => ''
  ]),
  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}}/disassociateresourceshare', [
  'body' => '{
  "resourceShareArn": "",
  "resourceArns": [],
  "principals": [],
  "clientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/disassociateresourceshare');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'resourceShareArn' => '',
  'resourceArns' => [
    
  ],
  'principals' => [
    
  ],
  'clientToken' => ''
]));

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

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

append(json_encode([
  'resourceShareArn' => '',
  'resourceArns' => [
    
  ],
  'principals' => [
    
  ],
  'clientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/disassociateresourceshare');
$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}}/disassociateresourceshare' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceShareArn": "",
  "resourceArns": [],
  "principals": [],
  "clientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/disassociateresourceshare' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceShareArn": "",
  "resourceArns": [],
  "principals": [],
  "clientToken": ""
}'

import http.client

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

payload = "{\n  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/disassociateresourceshare"

payload = {
    "resourceShareArn": "",
    "resourceArns": [],
    "principals": [],
    "clientToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/disassociateresourceshare"

payload <- "{\n  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\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}}/disassociateresourceshare")

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  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\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/disassociateresourceshare') do |req|
  req.body = "{\n  \"resourceShareArn\": \"\",\n  \"resourceArns\": [],\n  \"principals\": [],\n  \"clientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "resourceShareArn": "",
        "resourceArns": (),
        "principals": (),
        "clientToken": ""
    });

    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}}/disassociateresourceshare \
  --header 'content-type: application/json' \
  --data '{
  "resourceShareArn": "",
  "resourceArns": [],
  "principals": [],
  "clientToken": ""
}'

echo '{
  "resourceShareArn": "",
  "resourceArns": [],
  "principals": [],
  "clientToken": ""
}' |  \
  http POST {{baseUrl}}/disassociateresourceshare \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "resourceShareArn": "",\n  "resourceArns": [],\n  "principals": [],\n  "clientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/disassociateresourceshare

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "resourceShareArn": "",
  "resourceArns": [],
  "principals": [],
  "clientToken": ""
] as [String : Any]

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

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

{{baseUrl}}/disassociateresourcesharepermission

BODY json

{
  "resourceShareArn": "",
  "permissionArn": "",
  "clientToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/disassociateresourcesharepermission");

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  \"resourceShareArn\": \"\",\n  \"permissionArn\": \"\",\n  \"clientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/disassociateresourcesharepermission" {:content-type :json
                                                                                :form-params {:resourceShareArn ""
                                                                                              :permissionArn ""
                                                                                              :clientToken ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/disassociateresourcesharepermission"

	payload := strings.NewReader("{\n  \"resourceShareArn\": \"\",\n  \"permissionArn\": \"\",\n  \"clientToken\": \"\"\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/disassociateresourcesharepermission HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 72

{
  "resourceShareArn": "",
  "permissionArn": "",
  "clientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/disassociateresourcesharepermission")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"resourceShareArn\": \"\",\n  \"permissionArn\": \"\",\n  \"clientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/disassociateresourcesharepermission")
  .header("content-type", "application/json")
  .body("{\n  \"resourceShareArn\": \"\",\n  \"permissionArn\": \"\",\n  \"clientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  resourceShareArn: '',
  permissionArn: '',
  clientToken: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/disassociateresourcesharepermission',
  headers: {'content-type': 'application/json'},
  data: {resourceShareArn: '', permissionArn: '', clientToken: ''}
};

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

const url = '{{baseUrl}}/disassociateresourcesharepermission';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceShareArn":"","permissionArn":"","clientToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/disassociateresourcesharepermission',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "resourceShareArn": "",\n  "permissionArn": "",\n  "clientToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"resourceShareArn\": \"\",\n  \"permissionArn\": \"\",\n  \"clientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/disassociateresourcesharepermission")
  .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/disassociateresourcesharepermission',
  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({resourceShareArn: '', permissionArn: '', clientToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/disassociateresourcesharepermission',
  headers: {'content-type': 'application/json'},
  body: {resourceShareArn: '', permissionArn: '', clientToken: ''},
  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}}/disassociateresourcesharepermission');

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

req.type('json');
req.send({
  resourceShareArn: '',
  permissionArn: '',
  clientToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/disassociateresourcesharepermission',
  headers: {'content-type': 'application/json'},
  data: {resourceShareArn: '', permissionArn: '', clientToken: ''}
};

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

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

const url = '{{baseUrl}}/disassociateresourcesharepermission';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceShareArn":"","permissionArn":"","clientToken":""}'
};

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 = @{ @"resourceShareArn": @"",
                              @"permissionArn": @"",
                              @"clientToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/disassociateresourcesharepermission"]
                                                       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}}/disassociateresourcesharepermission" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"resourceShareArn\": \"\",\n  \"permissionArn\": \"\",\n  \"clientToken\": \"\"\n}" in

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

 "{{baseUrl}}/disassociateresourcesharepermission",
  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([
    'resourceShareArn' => '',
    'permissionArn' => '',
    'clientToken' => ''
  ]),
  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}}/disassociateresourcesharepermission', [
  'body' => '{
  "resourceShareArn": "",
  "permissionArn": "",
  "clientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/disassociateresourcesharepermission');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'resourceShareArn' => '',
  'permissionArn' => '',
  'clientToken' => ''
]));

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

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

append(json_encode([
  'resourceShareArn' => '',
  'permissionArn' => '',
  'clientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/disassociateresourcesharepermission');
$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}}/disassociateresourcesharepermission' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceShareArn": "",
  "permissionArn": "",
  "clientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/disassociateresourcesharepermission' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceShareArn": "",
  "permissionArn": "",
  "clientToken": ""
}'

import http.client

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

payload = "{\n  \"resourceShareArn\": \"\",\n  \"permissionArn\": \"\",\n  \"clientToken\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/disassociateresourcesharepermission"

payload = {
    "resourceShareArn": "",
    "permissionArn": "",
    "clientToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/disassociateresourcesharepermission"

payload <- "{\n  \"resourceShareArn\": \"\",\n  \"permissionArn\": \"\",\n  \"clientToken\": \"\"\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}}/disassociateresourcesharepermission")

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  \"resourceShareArn\": \"\",\n  \"permissionArn\": \"\",\n  \"clientToken\": \"\"\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/disassociateresourcesharepermission') do |req|
  req.body = "{\n  \"resourceShareArn\": \"\",\n  \"permissionArn\": \"\",\n  \"clientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "resourceShareArn": "",
        "permissionArn": "",
        "clientToken": ""
    });

    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}}/disassociateresourcesharepermission \
  --header 'content-type: application/json' \
  --data '{
  "resourceShareArn": "",
  "permissionArn": "",
  "clientToken": ""
}'

echo '{
  "resourceShareArn": "",
  "permissionArn": "",
  "clientToken": ""
}' |  \
  http POST {{baseUrl}}/disassociateresourcesharepermission \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "resourceShareArn": "",\n  "permissionArn": "",\n  "clientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/disassociateresourcesharepermission

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "resourceShareArn": "",
  "permissionArn": "",
  "clientToken": ""
] as [String : Any]

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

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

{{baseUrl}}/enablesharingwithawsorganization

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/enablesharingwithawsorganization");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/enablesharingwithawsorganization")

require "http/client"

url = "{{baseUrl}}/enablesharingwithawsorganization"

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}}/enablesharingwithawsorganization"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/enablesharingwithawsorganization");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/enablesharingwithawsorganization"

	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/enablesharingwithawsorganization HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/enablesharingwithawsorganization")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/enablesharingwithawsorganization"))
    .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}}/enablesharingwithawsorganization")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/enablesharingwithawsorganization")
  .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}}/enablesharingwithawsorganization');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/enablesharingwithawsorganization'
};

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

const url = '{{baseUrl}}/enablesharingwithawsorganization';
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}}/enablesharingwithawsorganization',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/enablesharingwithawsorganization")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/enablesharingwithawsorganization',
  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}}/enablesharingwithawsorganization'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/enablesharingwithawsorganization');

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/enablesharingwithawsorganization'
};

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

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

const url = '{{baseUrl}}/enablesharingwithawsorganization';
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}}/enablesharingwithawsorganization"]
                                                       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}}/enablesharingwithawsorganization" in

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

 "{{baseUrl}}/enablesharingwithawsorganization",
  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}}/enablesharingwithawsorganization');

echo $response->getBody();

setUrl('{{baseUrl}}/enablesharingwithawsorganization');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/enablesharingwithawsorganization');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/enablesharingwithawsorganization' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/enablesharingwithawsorganization' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/enablesharingwithawsorganization")

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

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

import requests

url = "{{baseUrl}}/enablesharingwithawsorganization"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/enablesharingwithawsorganization"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/enablesharingwithawsorganization")

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/enablesharingwithawsorganization') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/enablesharingwithawsorganization

http POST {{baseUrl}}/enablesharingwithawsorganization

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/enablesharingwithawsorganization

import Foundation

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

{{baseUrl}}/getpermission

BODY json

{
  "permissionArn": "",
  "permissionVersion": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/getpermission");

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  \"permissionArn\": \"\",\n  \"permissionVersion\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/getpermission" {:content-type :json
                                                          :form-params {:permissionArn ""
                                                                        :permissionVersion 0}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/getpermission"

	payload := strings.NewReader("{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 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/getpermission HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 51

{
  "permissionArn": "",
  "permissionVersion": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/getpermission")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/getpermission")
  .header("content-type", "application/json")
  .body("{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0\n}")
  .asString();

const data = JSON.stringify({
  permissionArn: '',
  permissionVersion: 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}}/getpermission');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/getpermission',
  headers: {'content-type': 'application/json'},
  data: {permissionArn: '', permissionVersion: 0}
};

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

const url = '{{baseUrl}}/getpermission';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"permissionArn":"","permissionVersion":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}}/getpermission',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "permissionArn": "",\n  "permissionVersion": 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  \"permissionArn\": \"\",\n  \"permissionVersion\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/getpermission")
  .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/getpermission',
  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({permissionArn: '', permissionVersion: 0}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/getpermission',
  headers: {'content-type': 'application/json'},
  body: {permissionArn: '', permissionVersion: 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}}/getpermission');

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

req.type('json');
req.send({
  permissionArn: '',
  permissionVersion: 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}}/getpermission',
  headers: {'content-type': 'application/json'},
  data: {permissionArn: '', permissionVersion: 0}
};

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

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

const url = '{{baseUrl}}/getpermission';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"permissionArn":"","permissionVersion":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 = @{ @"permissionArn": @"",
                              @"permissionVersion": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/getpermission"]
                                                       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}}/getpermission" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0\n}" in

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

 "{{baseUrl}}/getpermission",
  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([
    'permissionArn' => '',
    'permissionVersion' => 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}}/getpermission', [
  'body' => '{
  "permissionArn": "",
  "permissionVersion": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/getpermission');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'permissionArn' => '',
  'permissionVersion' => 0
]));

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

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

append(json_encode([
  'permissionArn' => '',
  'permissionVersion' => 0
]));
$request->setRequestUrl('{{baseUrl}}/getpermission');
$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}}/getpermission' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "permissionArn": "",
  "permissionVersion": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/getpermission' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "permissionArn": "",
  "permissionVersion": 0
}'

import http.client

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

payload = "{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/getpermission"

payload = {
    "permissionArn": "",
    "permissionVersion": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/getpermission"

payload <- "{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 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}}/getpermission")

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  \"permissionArn\": \"\",\n  \"permissionVersion\": 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/getpermission') do |req|
  req.body = "{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "permissionArn": "",
        "permissionVersion": 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}}/getpermission \
  --header 'content-type: application/json' \
  --data '{
  "permissionArn": "",
  "permissionVersion": 0
}'

echo '{
  "permissionArn": "",
  "permissionVersion": 0
}' |  \
  http POST {{baseUrl}}/getpermission \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "permissionArn": "",\n  "permissionVersion": 0\n}' \
  --output-document \
  - {{baseUrl}}/getpermission

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "permissionArn": "",
  "permissionVersion": 0
] as [String : Any]

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

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

{{baseUrl}}/getresourcepolicies

BODY json

{
  "resourceArns": [],
  "principal": "",
  "nextToken": "",
  "maxResults": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/getresourcepolicies");

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  \"resourceArns\": [],\n  \"principal\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/getresourcepolicies" {:content-type :json
                                                                :form-params {:resourceArns []
                                                                              :principal ""
                                                                              :nextToken ""
                                                                              :maxResults 0}})

require "http/client"

url = "{{baseUrl}}/getresourcepolicies"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"resourceArns\": [],\n  \"principal\": \"\",\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}}/getresourcepolicies"),
    Content = new StringContent("{\n  \"resourceArns\": [],\n  \"principal\": \"\",\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}}/getresourcepolicies");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"resourceArns\": [],\n  \"principal\": \"\",\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}}/getresourcepolicies"

	payload := strings.NewReader("{\n  \"resourceArns\": [],\n  \"principal\": \"\",\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/getresourcepolicies HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 81

{
  "resourceArns": [],
  "principal": "",
  "nextToken": "",
  "maxResults": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/getresourcepolicies")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"resourceArns\": [],\n  \"principal\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/getresourcepolicies"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"resourceArns\": [],\n  \"principal\": \"\",\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  \"resourceArns\": [],\n  \"principal\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/getresourcepolicies")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/getresourcepolicies")
  .header("content-type", "application/json")
  .body("{\n  \"resourceArns\": [],\n  \"principal\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
  .asString();

const data = JSON.stringify({
  resourceArns: [],
  principal: '',
  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}}/getresourcepolicies');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/getresourcepolicies',
  headers: {'content-type': 'application/json'},
  data: {resourceArns: [], principal: '', nextToken: '', maxResults: 0}
};

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

const url = '{{baseUrl}}/getresourcepolicies';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceArns":[],"principal":"","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}}/getresourcepolicies',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "resourceArns": [],\n  "principal": "",\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  \"resourceArns\": [],\n  \"principal\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/getresourcepolicies")
  .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/getresourcepolicies',
  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({resourceArns: [], principal: '', nextToken: '', maxResults: 0}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/getresourcepolicies',
  headers: {'content-type': 'application/json'},
  body: {resourceArns: [], principal: '', 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}}/getresourcepolicies');

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

req.type('json');
req.send({
  resourceArns: [],
  principal: '',
  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}}/getresourcepolicies',
  headers: {'content-type': 'application/json'},
  data: {resourceArns: [], principal: '', 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}}/getresourcepolicies';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceArns":[],"principal":"","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 = @{ @"resourceArns": @[  ],
                              @"principal": @"",
                              @"nextToken": @"",
                              @"maxResults": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/getresourcepolicies"]
                                                       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}}/getresourcepolicies" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"resourceArns\": [],\n  \"principal\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}" in

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

 "{{baseUrl}}/getresourcepolicies",
  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([
    'resourceArns' => [
        
    ],
    'principal' => '',
    '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}}/getresourcepolicies', [
  'body' => '{
  "resourceArns": [],
  "principal": "",
  "nextToken": "",
  "maxResults": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/getresourcepolicies');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'resourceArns' => [
    
  ],
  'principal' => '',
  'nextToken' => '',
  'maxResults' => 0
]));

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

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

append(json_encode([
  'resourceArns' => [
    
  ],
  'principal' => '',
  'nextToken' => '',
  'maxResults' => 0
]));
$request->setRequestUrl('{{baseUrl}}/getresourcepolicies');
$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}}/getresourcepolicies' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceArns": [],
  "principal": "",
  "nextToken": "",
  "maxResults": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/getresourcepolicies' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceArns": [],
  "principal": "",
  "nextToken": "",
  "maxResults": 0
}'

import http.client

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

payload = "{\n  \"resourceArns\": [],\n  \"principal\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/getresourcepolicies"

payload = {
    "resourceArns": [],
    "principal": "",
    "nextToken": "",
    "maxResults": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/getresourcepolicies"

payload <- "{\n  \"resourceArns\": [],\n  \"principal\": \"\",\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}}/getresourcepolicies")

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  \"resourceArns\": [],\n  \"principal\": \"\",\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/getresourcepolicies') do |req|
  req.body = "{\n  \"resourceArns\": [],\n  \"principal\": \"\",\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}}/getresourcepolicies";

    let payload = json!({
        "resourceArns": (),
        "principal": "",
        "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}}/getresourcepolicies \
  --header 'content-type: application/json' \
  --data '{
  "resourceArns": [],
  "principal": "",
  "nextToken": "",
  "maxResults": 0
}'

echo '{
  "resourceArns": [],
  "principal": "",
  "nextToken": "",
  "maxResults": 0
}' |  \
  http POST {{baseUrl}}/getresourcepolicies \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "resourceArns": [],\n  "principal": "",\n  "nextToken": "",\n  "maxResults": 0\n}' \
  --output-document \
  - {{baseUrl}}/getresourcepolicies

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "resourceArns": [],
  "principal": "",
  "nextToken": "",
  "maxResults": 0
] as [String : Any]

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

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

{{baseUrl}}/getresourceshareassociations

BODY json

{
  "associationType": "",
  "resourceShareArns": [],
  "resourceArn": "",
  "principal": "",
  "associationStatus": "",
  "nextToken": "",
  "maxResults": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/getresourceshareassociations");

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  \"associationType\": \"\",\n  \"resourceShareArns\": [],\n  \"resourceArn\": \"\",\n  \"principal\": \"\",\n  \"associationStatus\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/getresourceshareassociations" {:content-type :json
                                                                         :form-params {:associationType ""
                                                                                       :resourceShareArns []
                                                                                       :resourceArn ""
                                                                                       :principal ""
                                                                                       :associationStatus ""
                                                                                       :nextToken ""
                                                                                       :maxResults 0}})

require "http/client"

url = "{{baseUrl}}/getresourceshareassociations"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"associationType\": \"\",\n  \"resourceShareArns\": [],\n  \"resourceArn\": \"\",\n  \"principal\": \"\",\n  \"associationStatus\": \"\",\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}}/getresourceshareassociations"),
    Content = new StringContent("{\n  \"associationType\": \"\",\n  \"resourceShareArns\": [],\n  \"resourceArn\": \"\",\n  \"principal\": \"\",\n  \"associationStatus\": \"\",\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}}/getresourceshareassociations");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"associationType\": \"\",\n  \"resourceShareArns\": [],\n  \"resourceArn\": \"\",\n  \"principal\": \"\",\n  \"associationStatus\": \"\",\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}}/getresourceshareassociations"

	payload := strings.NewReader("{\n  \"associationType\": \"\",\n  \"resourceShareArns\": [],\n  \"resourceArn\": \"\",\n  \"principal\": \"\",\n  \"associationStatus\": \"\",\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/getresourceshareassociations HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 159

{
  "associationType": "",
  "resourceShareArns": [],
  "resourceArn": "",
  "principal": "",
  "associationStatus": "",
  "nextToken": "",
  "maxResults": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/getresourceshareassociations")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"associationType\": \"\",\n  \"resourceShareArns\": [],\n  \"resourceArn\": \"\",\n  \"principal\": \"\",\n  \"associationStatus\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/getresourceshareassociations"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"associationType\": \"\",\n  \"resourceShareArns\": [],\n  \"resourceArn\": \"\",\n  \"principal\": \"\",\n  \"associationStatus\": \"\",\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  \"associationType\": \"\",\n  \"resourceShareArns\": [],\n  \"resourceArn\": \"\",\n  \"principal\": \"\",\n  \"associationStatus\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/getresourceshareassociations")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/getresourceshareassociations")
  .header("content-type", "application/json")
  .body("{\n  \"associationType\": \"\",\n  \"resourceShareArns\": [],\n  \"resourceArn\": \"\",\n  \"principal\": \"\",\n  \"associationStatus\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
  .asString();

const data = JSON.stringify({
  associationType: '',
  resourceShareArns: [],
  resourceArn: '',
  principal: '',
  associationStatus: '',
  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}}/getresourceshareassociations');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/getresourceshareassociations',
  headers: {'content-type': 'application/json'},
  data: {
    associationType: '',
    resourceShareArns: [],
    resourceArn: '',
    principal: '',
    associationStatus: '',
    nextToken: '',
    maxResults: 0
  }
};

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

const url = '{{baseUrl}}/getresourceshareassociations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"associationType":"","resourceShareArns":[],"resourceArn":"","principal":"","associationStatus":"","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}}/getresourceshareassociations',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "associationType": "",\n  "resourceShareArns": [],\n  "resourceArn": "",\n  "principal": "",\n  "associationStatus": "",\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  \"associationType\": \"\",\n  \"resourceShareArns\": [],\n  \"resourceArn\": \"\",\n  \"principal\": \"\",\n  \"associationStatus\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/getresourceshareassociations")
  .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/getresourceshareassociations',
  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({
  associationType: '',
  resourceShareArns: [],
  resourceArn: '',
  principal: '',
  associationStatus: '',
  nextToken: '',
  maxResults: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/getresourceshareassociations',
  headers: {'content-type': 'application/json'},
  body: {
    associationType: '',
    resourceShareArns: [],
    resourceArn: '',
    principal: '',
    associationStatus: '',
    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}}/getresourceshareassociations');

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

req.type('json');
req.send({
  associationType: '',
  resourceShareArns: [],
  resourceArn: '',
  principal: '',
  associationStatus: '',
  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}}/getresourceshareassociations',
  headers: {'content-type': 'application/json'},
  data: {
    associationType: '',
    resourceShareArns: [],
    resourceArn: '',
    principal: '',
    associationStatus: '',
    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}}/getresourceshareassociations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"associationType":"","resourceShareArns":[],"resourceArn":"","principal":"","associationStatus":"","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 = @{ @"associationType": @"",
                              @"resourceShareArns": @[  ],
                              @"resourceArn": @"",
                              @"principal": @"",
                              @"associationStatus": @"",
                              @"nextToken": @"",
                              @"maxResults": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/getresourceshareassociations"]
                                                       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}}/getresourceshareassociations" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"associationType\": \"\",\n  \"resourceShareArns\": [],\n  \"resourceArn\": \"\",\n  \"principal\": \"\",\n  \"associationStatus\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}" in

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

 "{{baseUrl}}/getresourceshareassociations",
  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([
    'associationType' => '',
    'resourceShareArns' => [
        
    ],
    'resourceArn' => '',
    'principal' => '',
    'associationStatus' => '',
    '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}}/getresourceshareassociations', [
  'body' => '{
  "associationType": "",
  "resourceShareArns": [],
  "resourceArn": "",
  "principal": "",
  "associationStatus": "",
  "nextToken": "",
  "maxResults": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/getresourceshareassociations');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'associationType' => '',
  'resourceShareArns' => [
    
  ],
  'resourceArn' => '',
  'principal' => '',
  'associationStatus' => '',
  'nextToken' => '',
  'maxResults' => 0
]));

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

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

append(json_encode([
  'associationType' => '',
  'resourceShareArns' => [
    
  ],
  'resourceArn' => '',
  'principal' => '',
  'associationStatus' => '',
  'nextToken' => '',
  'maxResults' => 0
]));
$request->setRequestUrl('{{baseUrl}}/getresourceshareassociations');
$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}}/getresourceshareassociations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "associationType": "",
  "resourceShareArns": [],
  "resourceArn": "",
  "principal": "",
  "associationStatus": "",
  "nextToken": "",
  "maxResults": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/getresourceshareassociations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "associationType": "",
  "resourceShareArns": [],
  "resourceArn": "",
  "principal": "",
  "associationStatus": "",
  "nextToken": "",
  "maxResults": 0
}'

import http.client

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

payload = "{\n  \"associationType\": \"\",\n  \"resourceShareArns\": [],\n  \"resourceArn\": \"\",\n  \"principal\": \"\",\n  \"associationStatus\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/getresourceshareassociations"

payload = {
    "associationType": "",
    "resourceShareArns": [],
    "resourceArn": "",
    "principal": "",
    "associationStatus": "",
    "nextToken": "",
    "maxResults": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/getresourceshareassociations"

payload <- "{\n  \"associationType\": \"\",\n  \"resourceShareArns\": [],\n  \"resourceArn\": \"\",\n  \"principal\": \"\",\n  \"associationStatus\": \"\",\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}}/getresourceshareassociations")

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  \"associationType\": \"\",\n  \"resourceShareArns\": [],\n  \"resourceArn\": \"\",\n  \"principal\": \"\",\n  \"associationStatus\": \"\",\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/getresourceshareassociations') do |req|
  req.body = "{\n  \"associationType\": \"\",\n  \"resourceShareArns\": [],\n  \"resourceArn\": \"\",\n  \"principal\": \"\",\n  \"associationStatus\": \"\",\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}}/getresourceshareassociations";

    let payload = json!({
        "associationType": "",
        "resourceShareArns": (),
        "resourceArn": "",
        "principal": "",
        "associationStatus": "",
        "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}}/getresourceshareassociations \
  --header 'content-type: application/json' \
  --data '{
  "associationType": "",
  "resourceShareArns": [],
  "resourceArn": "",
  "principal": "",
  "associationStatus": "",
  "nextToken": "",
  "maxResults": 0
}'

echo '{
  "associationType": "",
  "resourceShareArns": [],
  "resourceArn": "",
  "principal": "",
  "associationStatus": "",
  "nextToken": "",
  "maxResults": 0
}' |  \
  http POST {{baseUrl}}/getresourceshareassociations \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "associationType": "",\n  "resourceShareArns": [],\n  "resourceArn": "",\n  "principal": "",\n  "associationStatus": "",\n  "nextToken": "",\n  "maxResults": 0\n}' \
  --output-document \
  - {{baseUrl}}/getresourceshareassociations

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "associationType": "",
  "resourceShareArns": [],
  "resourceArn": "",
  "principal": "",
  "associationStatus": "",
  "nextToken": "",
  "maxResults": 0
] as [String : Any]

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

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

{{baseUrl}}/getresourceshareinvitations

BODY json

{
  "resourceShareInvitationArns": [],
  "resourceShareArns": [],
  "nextToken": "",
  "maxResults": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/getresourceshareinvitations");

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  \"resourceShareInvitationArns\": [],\n  \"resourceShareArns\": [],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/getresourceshareinvitations" {:content-type :json
                                                                        :form-params {:resourceShareInvitationArns []
                                                                                      :resourceShareArns []
                                                                                      :nextToken ""
                                                                                      :maxResults 0}})

require "http/client"

url = "{{baseUrl}}/getresourceshareinvitations"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"resourceShareInvitationArns\": [],\n  \"resourceShareArns\": [],\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}}/getresourceshareinvitations"),
    Content = new StringContent("{\n  \"resourceShareInvitationArns\": [],\n  \"resourceShareArns\": [],\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}}/getresourceshareinvitations");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"resourceShareInvitationArns\": [],\n  \"resourceShareArns\": [],\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}}/getresourceshareinvitations"

	payload := strings.NewReader("{\n  \"resourceShareInvitationArns\": [],\n  \"resourceShareArns\": [],\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/getresourceshareinvitations HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 104

{
  "resourceShareInvitationArns": [],
  "resourceShareArns": [],
  "nextToken": "",
  "maxResults": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/getresourceshareinvitations")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"resourceShareInvitationArns\": [],\n  \"resourceShareArns\": [],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/getresourceshareinvitations"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"resourceShareInvitationArns\": [],\n  \"resourceShareArns\": [],\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  \"resourceShareInvitationArns\": [],\n  \"resourceShareArns\": [],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/getresourceshareinvitations")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/getresourceshareinvitations")
  .header("content-type", "application/json")
  .body("{\n  \"resourceShareInvitationArns\": [],\n  \"resourceShareArns\": [],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
  .asString();

const data = JSON.stringify({
  resourceShareInvitationArns: [],
  resourceShareArns: [],
  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}}/getresourceshareinvitations');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/getresourceshareinvitations',
  headers: {'content-type': 'application/json'},
  data: {
    resourceShareInvitationArns: [],
    resourceShareArns: [],
    nextToken: '',
    maxResults: 0
  }
};

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

const url = '{{baseUrl}}/getresourceshareinvitations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceShareInvitationArns":[],"resourceShareArns":[],"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}}/getresourceshareinvitations',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "resourceShareInvitationArns": [],\n  "resourceShareArns": [],\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  \"resourceShareInvitationArns\": [],\n  \"resourceShareArns\": [],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/getresourceshareinvitations")
  .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/getresourceshareinvitations',
  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({
  resourceShareInvitationArns: [],
  resourceShareArns: [],
  nextToken: '',
  maxResults: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/getresourceshareinvitations',
  headers: {'content-type': 'application/json'},
  body: {
    resourceShareInvitationArns: [],
    resourceShareArns: [],
    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}}/getresourceshareinvitations');

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

req.type('json');
req.send({
  resourceShareInvitationArns: [],
  resourceShareArns: [],
  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}}/getresourceshareinvitations',
  headers: {'content-type': 'application/json'},
  data: {
    resourceShareInvitationArns: [],
    resourceShareArns: [],
    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}}/getresourceshareinvitations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceShareInvitationArns":[],"resourceShareArns":[],"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 = @{ @"resourceShareInvitationArns": @[  ],
                              @"resourceShareArns": @[  ],
                              @"nextToken": @"",
                              @"maxResults": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/getresourceshareinvitations"]
                                                       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}}/getresourceshareinvitations" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"resourceShareInvitationArns\": [],\n  \"resourceShareArns\": [],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}" in

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

 "{{baseUrl}}/getresourceshareinvitations",
  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([
    'resourceShareInvitationArns' => [
        
    ],
    'resourceShareArns' => [
        
    ],
    '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}}/getresourceshareinvitations', [
  'body' => '{
  "resourceShareInvitationArns": [],
  "resourceShareArns": [],
  "nextToken": "",
  "maxResults": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/getresourceshareinvitations');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'resourceShareInvitationArns' => [
    
  ],
  'resourceShareArns' => [
    
  ],
  'nextToken' => '',
  'maxResults' => 0
]));

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

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

append(json_encode([
  'resourceShareInvitationArns' => [
    
  ],
  'resourceShareArns' => [
    
  ],
  'nextToken' => '',
  'maxResults' => 0
]));
$request->setRequestUrl('{{baseUrl}}/getresourceshareinvitations');
$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}}/getresourceshareinvitations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceShareInvitationArns": [],
  "resourceShareArns": [],
  "nextToken": "",
  "maxResults": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/getresourceshareinvitations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceShareInvitationArns": [],
  "resourceShareArns": [],
  "nextToken": "",
  "maxResults": 0
}'

import http.client

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

payload = "{\n  \"resourceShareInvitationArns\": [],\n  \"resourceShareArns\": [],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/getresourceshareinvitations"

payload = {
    "resourceShareInvitationArns": [],
    "resourceShareArns": [],
    "nextToken": "",
    "maxResults": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/getresourceshareinvitations"

payload <- "{\n  \"resourceShareInvitationArns\": [],\n  \"resourceShareArns\": [],\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}}/getresourceshareinvitations")

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  \"resourceShareInvitationArns\": [],\n  \"resourceShareArns\": [],\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/getresourceshareinvitations') do |req|
  req.body = "{\n  \"resourceShareInvitationArns\": [],\n  \"resourceShareArns\": [],\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}}/getresourceshareinvitations";

    let payload = json!({
        "resourceShareInvitationArns": (),
        "resourceShareArns": (),
        "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}}/getresourceshareinvitations \
  --header 'content-type: application/json' \
  --data '{
  "resourceShareInvitationArns": [],
  "resourceShareArns": [],
  "nextToken": "",
  "maxResults": 0
}'

echo '{
  "resourceShareInvitationArns": [],
  "resourceShareArns": [],
  "nextToken": "",
  "maxResults": 0
}' |  \
  http POST {{baseUrl}}/getresourceshareinvitations \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "resourceShareInvitationArns": [],\n  "resourceShareArns": [],\n  "nextToken": "",\n  "maxResults": 0\n}' \
  --output-document \
  - {{baseUrl}}/getresourceshareinvitations

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "resourceShareInvitationArns": [],
  "resourceShareArns": [],
  "nextToken": "",
  "maxResults": 0
] as [String : Any]

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

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

{{baseUrl}}/getresourceshares

BODY json

{
  "resourceShareArns": [],
  "resourceShareStatus": "",
  "resourceOwner": "",
  "name": "",
  "tagFilters": [
    {
      "tagKey": "",
      "tagValues": ""
    }
  ],
  "nextToken": "",
  "maxResults": 0,
  "permissionArn": "",
  "permissionVersion": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/getresourceshares");

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  \"resourceShareArns\": [],\n  \"resourceShareStatus\": \"\",\n  \"resourceOwner\": \"\",\n  \"name\": \"\",\n  \"tagFilters\": [\n    {\n      \"tagKey\": \"\",\n      \"tagValues\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/getresourceshares" {:content-type :json
                                                              :form-params {:resourceShareArns []
                                                                            :resourceShareStatus ""
                                                                            :resourceOwner ""
                                                                            :name ""
                                                                            :tagFilters [{:tagKey ""
                                                                                          :tagValues ""}]
                                                                            :nextToken ""
                                                                            :maxResults 0
                                                                            :permissionArn ""
                                                                            :permissionVersion 0}})

require "http/client"

url = "{{baseUrl}}/getresourceshares"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"resourceShareArns\": [],\n  \"resourceShareStatus\": \"\",\n  \"resourceOwner\": \"\",\n  \"name\": \"\",\n  \"tagFilters\": [\n    {\n      \"tagKey\": \"\",\n      \"tagValues\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 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}}/getresourceshares"),
    Content = new StringContent("{\n  \"resourceShareArns\": [],\n  \"resourceShareStatus\": \"\",\n  \"resourceOwner\": \"\",\n  \"name\": \"\",\n  \"tagFilters\": [\n    {\n      \"tagKey\": \"\",\n      \"tagValues\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 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}}/getresourceshares");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"resourceShareArns\": [],\n  \"resourceShareStatus\": \"\",\n  \"resourceOwner\": \"\",\n  \"name\": \"\",\n  \"tagFilters\": [\n    {\n      \"tagKey\": \"\",\n      \"tagValues\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/getresourceshares"

	payload := strings.NewReader("{\n  \"resourceShareArns\": [],\n  \"resourceShareStatus\": \"\",\n  \"resourceOwner\": \"\",\n  \"name\": \"\",\n  \"tagFilters\": [\n    {\n      \"tagKey\": \"\",\n      \"tagValues\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 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/getresourceshares HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 259

{
  "resourceShareArns": [],
  "resourceShareStatus": "",
  "resourceOwner": "",
  "name": "",
  "tagFilters": [
    {
      "tagKey": "",
      "tagValues": ""
    }
  ],
  "nextToken": "",
  "maxResults": 0,
  "permissionArn": "",
  "permissionVersion": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/getresourceshares")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"resourceShareArns\": [],\n  \"resourceShareStatus\": \"\",\n  \"resourceOwner\": \"\",\n  \"name\": \"\",\n  \"tagFilters\": [\n    {\n      \"tagKey\": \"\",\n      \"tagValues\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/getresourceshares"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"resourceShareArns\": [],\n  \"resourceShareStatus\": \"\",\n  \"resourceOwner\": \"\",\n  \"name\": \"\",\n  \"tagFilters\": [\n    {\n      \"tagKey\": \"\",\n      \"tagValues\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 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  \"resourceShareArns\": [],\n  \"resourceShareStatus\": \"\",\n  \"resourceOwner\": \"\",\n  \"name\": \"\",\n  \"tagFilters\": [\n    {\n      \"tagKey\": \"\",\n      \"tagValues\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/getresourceshares")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/getresourceshares")
  .header("content-type", "application/json")
  .body("{\n  \"resourceShareArns\": [],\n  \"resourceShareStatus\": \"\",\n  \"resourceOwner\": \"\",\n  \"name\": \"\",\n  \"tagFilters\": [\n    {\n      \"tagKey\": \"\",\n      \"tagValues\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0\n}")
  .asString();

const data = JSON.stringify({
  resourceShareArns: [],
  resourceShareStatus: '',
  resourceOwner: '',
  name: '',
  tagFilters: [
    {
      tagKey: '',
      tagValues: ''
    }
  ],
  nextToken: '',
  maxResults: 0,
  permissionArn: '',
  permissionVersion: 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}}/getresourceshares');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/getresourceshares',
  headers: {'content-type': 'application/json'},
  data: {
    resourceShareArns: [],
    resourceShareStatus: '',
    resourceOwner: '',
    name: '',
    tagFilters: [{tagKey: '', tagValues: ''}],
    nextToken: '',
    maxResults: 0,
    permissionArn: '',
    permissionVersion: 0
  }
};

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

const url = '{{baseUrl}}/getresourceshares';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceShareArns":[],"resourceShareStatus":"","resourceOwner":"","name":"","tagFilters":[{"tagKey":"","tagValues":""}],"nextToken":"","maxResults":0,"permissionArn":"","permissionVersion":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}}/getresourceshares',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "resourceShareArns": [],\n  "resourceShareStatus": "",\n  "resourceOwner": "",\n  "name": "",\n  "tagFilters": [\n    {\n      "tagKey": "",\n      "tagValues": ""\n    }\n  ],\n  "nextToken": "",\n  "maxResults": 0,\n  "permissionArn": "",\n  "permissionVersion": 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  \"resourceShareArns\": [],\n  \"resourceShareStatus\": \"\",\n  \"resourceOwner\": \"\",\n  \"name\": \"\",\n  \"tagFilters\": [\n    {\n      \"tagKey\": \"\",\n      \"tagValues\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/getresourceshares")
  .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/getresourceshares',
  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({
  resourceShareArns: [],
  resourceShareStatus: '',
  resourceOwner: '',
  name: '',
  tagFilters: [{tagKey: '', tagValues: ''}],
  nextToken: '',
  maxResults: 0,
  permissionArn: '',
  permissionVersion: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/getresourceshares',
  headers: {'content-type': 'application/json'},
  body: {
    resourceShareArns: [],
    resourceShareStatus: '',
    resourceOwner: '',
    name: '',
    tagFilters: [{tagKey: '', tagValues: ''}],
    nextToken: '',
    maxResults: 0,
    permissionArn: '',
    permissionVersion: 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}}/getresourceshares');

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

req.type('json');
req.send({
  resourceShareArns: [],
  resourceShareStatus: '',
  resourceOwner: '',
  name: '',
  tagFilters: [
    {
      tagKey: '',
      tagValues: ''
    }
  ],
  nextToken: '',
  maxResults: 0,
  permissionArn: '',
  permissionVersion: 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}}/getresourceshares',
  headers: {'content-type': 'application/json'},
  data: {
    resourceShareArns: [],
    resourceShareStatus: '',
    resourceOwner: '',
    name: '',
    tagFilters: [{tagKey: '', tagValues: ''}],
    nextToken: '',
    maxResults: 0,
    permissionArn: '',
    permissionVersion: 0
  }
};

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

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

const url = '{{baseUrl}}/getresourceshares';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceShareArns":[],"resourceShareStatus":"","resourceOwner":"","name":"","tagFilters":[{"tagKey":"","tagValues":""}],"nextToken":"","maxResults":0,"permissionArn":"","permissionVersion":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 = @{ @"resourceShareArns": @[  ],
                              @"resourceShareStatus": @"",
                              @"resourceOwner": @"",
                              @"name": @"",
                              @"tagFilters": @[ @{ @"tagKey": @"", @"tagValues": @"" } ],
                              @"nextToken": @"",
                              @"maxResults": @0,
                              @"permissionArn": @"",
                              @"permissionVersion": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/getresourceshares"]
                                                       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}}/getresourceshares" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"resourceShareArns\": [],\n  \"resourceShareStatus\": \"\",\n  \"resourceOwner\": \"\",\n  \"name\": \"\",\n  \"tagFilters\": [\n    {\n      \"tagKey\": \"\",\n      \"tagValues\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0\n}" in

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

 "{{baseUrl}}/getresourceshares",
  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([
    'resourceShareArns' => [
        
    ],
    'resourceShareStatus' => '',
    'resourceOwner' => '',
    'name' => '',
    'tagFilters' => [
        [
                'tagKey' => '',
                'tagValues' => ''
        ]
    ],
    'nextToken' => '',
    'maxResults' => 0,
    'permissionArn' => '',
    'permissionVersion' => 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}}/getresourceshares', [
  'body' => '{
  "resourceShareArns": [],
  "resourceShareStatus": "",
  "resourceOwner": "",
  "name": "",
  "tagFilters": [
    {
      "tagKey": "",
      "tagValues": ""
    }
  ],
  "nextToken": "",
  "maxResults": 0,
  "permissionArn": "",
  "permissionVersion": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/getresourceshares');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'resourceShareArns' => [
    
  ],
  'resourceShareStatus' => '',
  'resourceOwner' => '',
  'name' => '',
  'tagFilters' => [
    [
        'tagKey' => '',
        'tagValues' => ''
    ]
  ],
  'nextToken' => '',
  'maxResults' => 0,
  'permissionArn' => '',
  'permissionVersion' => 0
]));

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

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

append(json_encode([
  'resourceShareArns' => [
    
  ],
  'resourceShareStatus' => '',
  'resourceOwner' => '',
  'name' => '',
  'tagFilters' => [
    [
        'tagKey' => '',
        'tagValues' => ''
    ]
  ],
  'nextToken' => '',
  'maxResults' => 0,
  'permissionArn' => '',
  'permissionVersion' => 0
]));
$request->setRequestUrl('{{baseUrl}}/getresourceshares');
$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}}/getresourceshares' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceShareArns": [],
  "resourceShareStatus": "",
  "resourceOwner": "",
  "name": "",
  "tagFilters": [
    {
      "tagKey": "",
      "tagValues": ""
    }
  ],
  "nextToken": "",
  "maxResults": 0,
  "permissionArn": "",
  "permissionVersion": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/getresourceshares' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceShareArns": [],
  "resourceShareStatus": "",
  "resourceOwner": "",
  "name": "",
  "tagFilters": [
    {
      "tagKey": "",
      "tagValues": ""
    }
  ],
  "nextToken": "",
  "maxResults": 0,
  "permissionArn": "",
  "permissionVersion": 0
}'

import http.client

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

payload = "{\n  \"resourceShareArns\": [],\n  \"resourceShareStatus\": \"\",\n  \"resourceOwner\": \"\",\n  \"name\": \"\",\n  \"tagFilters\": [\n    {\n      \"tagKey\": \"\",\n      \"tagValues\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/getresourceshares"

payload = {
    "resourceShareArns": [],
    "resourceShareStatus": "",
    "resourceOwner": "",
    "name": "",
    "tagFilters": [
        {
            "tagKey": "",
            "tagValues": ""
        }
    ],
    "nextToken": "",
    "maxResults": 0,
    "permissionArn": "",
    "permissionVersion": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/getresourceshares"

payload <- "{\n  \"resourceShareArns\": [],\n  \"resourceShareStatus\": \"\",\n  \"resourceOwner\": \"\",\n  \"name\": \"\",\n  \"tagFilters\": [\n    {\n      \"tagKey\": \"\",\n      \"tagValues\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 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}}/getresourceshares")

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  \"resourceShareArns\": [],\n  \"resourceShareStatus\": \"\",\n  \"resourceOwner\": \"\",\n  \"name\": \"\",\n  \"tagFilters\": [\n    {\n      \"tagKey\": \"\",\n      \"tagValues\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 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/getresourceshares') do |req|
  req.body = "{\n  \"resourceShareArns\": [],\n  \"resourceShareStatus\": \"\",\n  \"resourceOwner\": \"\",\n  \"name\": \"\",\n  \"tagFilters\": [\n    {\n      \"tagKey\": \"\",\n      \"tagValues\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "resourceShareArns": (),
        "resourceShareStatus": "",
        "resourceOwner": "",
        "name": "",
        "tagFilters": (
            json!({
                "tagKey": "",
                "tagValues": ""
            })
        ),
        "nextToken": "",
        "maxResults": 0,
        "permissionArn": "",
        "permissionVersion": 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}}/getresourceshares \
  --header 'content-type: application/json' \
  --data '{
  "resourceShareArns": [],
  "resourceShareStatus": "",
  "resourceOwner": "",
  "name": "",
  "tagFilters": [
    {
      "tagKey": "",
      "tagValues": ""
    }
  ],
  "nextToken": "",
  "maxResults": 0,
  "permissionArn": "",
  "permissionVersion": 0
}'

echo '{
  "resourceShareArns": [],
  "resourceShareStatus": "",
  "resourceOwner": "",
  "name": "",
  "tagFilters": [
    {
      "tagKey": "",
      "tagValues": ""
    }
  ],
  "nextToken": "",
  "maxResults": 0,
  "permissionArn": "",
  "permissionVersion": 0
}' |  \
  http POST {{baseUrl}}/getresourceshares \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "resourceShareArns": [],\n  "resourceShareStatus": "",\n  "resourceOwner": "",\n  "name": "",\n  "tagFilters": [\n    {\n      "tagKey": "",\n      "tagValues": ""\n    }\n  ],\n  "nextToken": "",\n  "maxResults": 0,\n  "permissionArn": "",\n  "permissionVersion": 0\n}' \
  --output-document \
  - {{baseUrl}}/getresourceshares

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "resourceShareArns": [],
  "resourceShareStatus": "",
  "resourceOwner": "",
  "name": "",
  "tagFilters": [
    [
      "tagKey": "",
      "tagValues": ""
    ]
  ],
  "nextToken": "",
  "maxResults": 0,
  "permissionArn": "",
  "permissionVersion": 0
] as [String : Any]

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

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

{{baseUrl}}/listpendinginvitationresources

BODY json

{
  "resourceShareInvitationArn": "",
  "nextToken": "",
  "maxResults": 0,
  "resourceRegionScope": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listpendinginvitationresources");

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  \"resourceShareInvitationArn\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/listpendinginvitationresources" {:content-type :json
                                                                           :form-params {:resourceShareInvitationArn ""
                                                                                         :nextToken ""
                                                                                         :maxResults 0
                                                                                         :resourceRegionScope ""}})

require "http/client"

url = "{{baseUrl}}/listpendinginvitationresources"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"resourceShareInvitationArn\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\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}}/listpendinginvitationresources"),
    Content = new StringContent("{\n  \"resourceShareInvitationArn\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\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}}/listpendinginvitationresources");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"resourceShareInvitationArn\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/listpendinginvitationresources"

	payload := strings.NewReader("{\n  \"resourceShareInvitationArn\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\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/listpendinginvitationresources HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 105

{
  "resourceShareInvitationArn": "",
  "nextToken": "",
  "maxResults": 0,
  "resourceRegionScope": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/listpendinginvitationresources")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"resourceShareInvitationArn\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listpendinginvitationresources"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"resourceShareInvitationArn\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\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  \"resourceShareInvitationArn\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/listpendinginvitationresources")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/listpendinginvitationresources")
  .header("content-type", "application/json")
  .body("{\n  \"resourceShareInvitationArn\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  resourceShareInvitationArn: '',
  nextToken: '',
  maxResults: 0,
  resourceRegionScope: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listpendinginvitationresources',
  headers: {'content-type': 'application/json'},
  data: {
    resourceShareInvitationArn: '',
    nextToken: '',
    maxResults: 0,
    resourceRegionScope: ''
  }
};

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

const url = '{{baseUrl}}/listpendinginvitationresources';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceShareInvitationArn":"","nextToken":"","maxResults":0,"resourceRegionScope":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/listpendinginvitationresources',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "resourceShareInvitationArn": "",\n  "nextToken": "",\n  "maxResults": 0,\n  "resourceRegionScope": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"resourceShareInvitationArn\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/listpendinginvitationresources")
  .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/listpendinginvitationresources',
  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({
  resourceShareInvitationArn: '',
  nextToken: '',
  maxResults: 0,
  resourceRegionScope: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listpendinginvitationresources',
  headers: {'content-type': 'application/json'},
  body: {
    resourceShareInvitationArn: '',
    nextToken: '',
    maxResults: 0,
    resourceRegionScope: ''
  },
  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}}/listpendinginvitationresources');

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

req.type('json');
req.send({
  resourceShareInvitationArn: '',
  nextToken: '',
  maxResults: 0,
  resourceRegionScope: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listpendinginvitationresources',
  headers: {'content-type': 'application/json'},
  data: {
    resourceShareInvitationArn: '',
    nextToken: '',
    maxResults: 0,
    resourceRegionScope: ''
  }
};

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

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

const url = '{{baseUrl}}/listpendinginvitationresources';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceShareInvitationArn":"","nextToken":"","maxResults":0,"resourceRegionScope":""}'
};

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 = @{ @"resourceShareInvitationArn": @"",
                              @"nextToken": @"",
                              @"maxResults": @0,
                              @"resourceRegionScope": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/listpendinginvitationresources"]
                                                       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}}/listpendinginvitationresources" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"resourceShareInvitationArn\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\n}" in

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

 "{{baseUrl}}/listpendinginvitationresources",
  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([
    'resourceShareInvitationArn' => '',
    'nextToken' => '',
    'maxResults' => 0,
    'resourceRegionScope' => ''
  ]),
  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}}/listpendinginvitationresources', [
  'body' => '{
  "resourceShareInvitationArn": "",
  "nextToken": "",
  "maxResults": 0,
  "resourceRegionScope": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/listpendinginvitationresources');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'resourceShareInvitationArn' => '',
  'nextToken' => '',
  'maxResults' => 0,
  'resourceRegionScope' => ''
]));

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

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

append(json_encode([
  'resourceShareInvitationArn' => '',
  'nextToken' => '',
  'maxResults' => 0,
  'resourceRegionScope' => ''
]));
$request->setRequestUrl('{{baseUrl}}/listpendinginvitationresources');
$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}}/listpendinginvitationresources' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceShareInvitationArn": "",
  "nextToken": "",
  "maxResults": 0,
  "resourceRegionScope": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/listpendinginvitationresources' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceShareInvitationArn": "",
  "nextToken": "",
  "maxResults": 0,
  "resourceRegionScope": ""
}'

import http.client

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

payload = "{\n  \"resourceShareInvitationArn\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/listpendinginvitationresources"

payload = {
    "resourceShareInvitationArn": "",
    "nextToken": "",
    "maxResults": 0,
    "resourceRegionScope": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/listpendinginvitationresources"

payload <- "{\n  \"resourceShareInvitationArn\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\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}}/listpendinginvitationresources")

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  \"resourceShareInvitationArn\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\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/listpendinginvitationresources') do |req|
  req.body = "{\n  \"resourceShareInvitationArn\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "resourceShareInvitationArn": "",
        "nextToken": "",
        "maxResults": 0,
        "resourceRegionScope": ""
    });

    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}}/listpendinginvitationresources \
  --header 'content-type: application/json' \
  --data '{
  "resourceShareInvitationArn": "",
  "nextToken": "",
  "maxResults": 0,
  "resourceRegionScope": ""
}'

echo '{
  "resourceShareInvitationArn": "",
  "nextToken": "",
  "maxResults": 0,
  "resourceRegionScope": ""
}' |  \
  http POST {{baseUrl}}/listpendinginvitationresources \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "resourceShareInvitationArn": "",\n  "nextToken": "",\n  "maxResults": 0,\n  "resourceRegionScope": ""\n}' \
  --output-document \
  - {{baseUrl}}/listpendinginvitationresources

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "resourceShareInvitationArn": "",
  "nextToken": "",
  "maxResults": 0,
  "resourceRegionScope": ""
] as [String : Any]

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

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

{{baseUrl}}/listpermissionassociations

BODY json

{
  "permissionArn": "",
  "permissionVersion": 0,
  "associationStatus": "",
  "resourceType": "",
  "featureSet": "",
  "defaultVersion": false,
  "nextToken": "",
  "maxResults": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listpermissionassociations");

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  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"associationStatus\": \"\",\n  \"resourceType\": \"\",\n  \"featureSet\": \"\",\n  \"defaultVersion\": false,\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/listpermissionassociations" {:content-type :json
                                                                       :form-params {:permissionArn ""
                                                                                     :permissionVersion 0
                                                                                     :associationStatus ""
                                                                                     :resourceType ""
                                                                                     :featureSet ""
                                                                                     :defaultVersion false
                                                                                     :nextToken ""
                                                                                     :maxResults 0}})

require "http/client"

url = "{{baseUrl}}/listpermissionassociations"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"associationStatus\": \"\",\n  \"resourceType\": \"\",\n  \"featureSet\": \"\",\n  \"defaultVersion\": false,\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}}/listpermissionassociations"),
    Content = new StringContent("{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"associationStatus\": \"\",\n  \"resourceType\": \"\",\n  \"featureSet\": \"\",\n  \"defaultVersion\": false,\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}}/listpermissionassociations");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"associationStatus\": \"\",\n  \"resourceType\": \"\",\n  \"featureSet\": \"\",\n  \"defaultVersion\": false,\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}}/listpermissionassociations"

	payload := strings.NewReader("{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"associationStatus\": \"\",\n  \"resourceType\": \"\",\n  \"featureSet\": \"\",\n  \"defaultVersion\": false,\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/listpermissionassociations HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 185

{
  "permissionArn": "",
  "permissionVersion": 0,
  "associationStatus": "",
  "resourceType": "",
  "featureSet": "",
  "defaultVersion": false,
  "nextToken": "",
  "maxResults": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/listpermissionassociations")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"associationStatus\": \"\",\n  \"resourceType\": \"\",\n  \"featureSet\": \"\",\n  \"defaultVersion\": false,\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listpermissionassociations"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"associationStatus\": \"\",\n  \"resourceType\": \"\",\n  \"featureSet\": \"\",\n  \"defaultVersion\": false,\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  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"associationStatus\": \"\",\n  \"resourceType\": \"\",\n  \"featureSet\": \"\",\n  \"defaultVersion\": false,\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/listpermissionassociations")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/listpermissionassociations")
  .header("content-type", "application/json")
  .body("{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"associationStatus\": \"\",\n  \"resourceType\": \"\",\n  \"featureSet\": \"\",\n  \"defaultVersion\": false,\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
  .asString();

const data = JSON.stringify({
  permissionArn: '',
  permissionVersion: 0,
  associationStatus: '',
  resourceType: '',
  featureSet: '',
  defaultVersion: false,
  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}}/listpermissionassociations');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listpermissionassociations',
  headers: {'content-type': 'application/json'},
  data: {
    permissionArn: '',
    permissionVersion: 0,
    associationStatus: '',
    resourceType: '',
    featureSet: '',
    defaultVersion: false,
    nextToken: '',
    maxResults: 0
  }
};

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

const url = '{{baseUrl}}/listpermissionassociations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"permissionArn":"","permissionVersion":0,"associationStatus":"","resourceType":"","featureSet":"","defaultVersion":false,"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}}/listpermissionassociations',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "permissionArn": "",\n  "permissionVersion": 0,\n  "associationStatus": "",\n  "resourceType": "",\n  "featureSet": "",\n  "defaultVersion": false,\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  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"associationStatus\": \"\",\n  \"resourceType\": \"\",\n  \"featureSet\": \"\",\n  \"defaultVersion\": false,\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/listpermissionassociations")
  .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/listpermissionassociations',
  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({
  permissionArn: '',
  permissionVersion: 0,
  associationStatus: '',
  resourceType: '',
  featureSet: '',
  defaultVersion: false,
  nextToken: '',
  maxResults: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listpermissionassociations',
  headers: {'content-type': 'application/json'},
  body: {
    permissionArn: '',
    permissionVersion: 0,
    associationStatus: '',
    resourceType: '',
    featureSet: '',
    defaultVersion: false,
    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}}/listpermissionassociations');

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

req.type('json');
req.send({
  permissionArn: '',
  permissionVersion: 0,
  associationStatus: '',
  resourceType: '',
  featureSet: '',
  defaultVersion: false,
  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}}/listpermissionassociations',
  headers: {'content-type': 'application/json'},
  data: {
    permissionArn: '',
    permissionVersion: 0,
    associationStatus: '',
    resourceType: '',
    featureSet: '',
    defaultVersion: false,
    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}}/listpermissionassociations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"permissionArn":"","permissionVersion":0,"associationStatus":"","resourceType":"","featureSet":"","defaultVersion":false,"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 = @{ @"permissionArn": @"",
                              @"permissionVersion": @0,
                              @"associationStatus": @"",
                              @"resourceType": @"",
                              @"featureSet": @"",
                              @"defaultVersion": @NO,
                              @"nextToken": @"",
                              @"maxResults": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/listpermissionassociations"]
                                                       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}}/listpermissionassociations" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"associationStatus\": \"\",\n  \"resourceType\": \"\",\n  \"featureSet\": \"\",\n  \"defaultVersion\": false,\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}" in

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

 "{{baseUrl}}/listpermissionassociations",
  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([
    'permissionArn' => '',
    'permissionVersion' => 0,
    'associationStatus' => '',
    'resourceType' => '',
    'featureSet' => '',
    'defaultVersion' => null,
    '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}}/listpermissionassociations', [
  'body' => '{
  "permissionArn": "",
  "permissionVersion": 0,
  "associationStatus": "",
  "resourceType": "",
  "featureSet": "",
  "defaultVersion": false,
  "nextToken": "",
  "maxResults": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/listpermissionassociations');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'permissionArn' => '',
  'permissionVersion' => 0,
  'associationStatus' => '',
  'resourceType' => '',
  'featureSet' => '',
  'defaultVersion' => null,
  'nextToken' => '',
  'maxResults' => 0
]));

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

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

append(json_encode([
  'permissionArn' => '',
  'permissionVersion' => 0,
  'associationStatus' => '',
  'resourceType' => '',
  'featureSet' => '',
  'defaultVersion' => null,
  'nextToken' => '',
  'maxResults' => 0
]));
$request->setRequestUrl('{{baseUrl}}/listpermissionassociations');
$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}}/listpermissionassociations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "permissionArn": "",
  "permissionVersion": 0,
  "associationStatus": "",
  "resourceType": "",
  "featureSet": "",
  "defaultVersion": false,
  "nextToken": "",
  "maxResults": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/listpermissionassociations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "permissionArn": "",
  "permissionVersion": 0,
  "associationStatus": "",
  "resourceType": "",
  "featureSet": "",
  "defaultVersion": false,
  "nextToken": "",
  "maxResults": 0
}'

import http.client

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

payload = "{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"associationStatus\": \"\",\n  \"resourceType\": \"\",\n  \"featureSet\": \"\",\n  \"defaultVersion\": false,\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/listpermissionassociations"

payload = {
    "permissionArn": "",
    "permissionVersion": 0,
    "associationStatus": "",
    "resourceType": "",
    "featureSet": "",
    "defaultVersion": False,
    "nextToken": "",
    "maxResults": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/listpermissionassociations"

payload <- "{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"associationStatus\": \"\",\n  \"resourceType\": \"\",\n  \"featureSet\": \"\",\n  \"defaultVersion\": false,\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}}/listpermissionassociations")

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  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"associationStatus\": \"\",\n  \"resourceType\": \"\",\n  \"featureSet\": \"\",\n  \"defaultVersion\": false,\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/listpermissionassociations') do |req|
  req.body = "{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"associationStatus\": \"\",\n  \"resourceType\": \"\",\n  \"featureSet\": \"\",\n  \"defaultVersion\": false,\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}}/listpermissionassociations";

    let payload = json!({
        "permissionArn": "",
        "permissionVersion": 0,
        "associationStatus": "",
        "resourceType": "",
        "featureSet": "",
        "defaultVersion": false,
        "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}}/listpermissionassociations \
  --header 'content-type: application/json' \
  --data '{
  "permissionArn": "",
  "permissionVersion": 0,
  "associationStatus": "",
  "resourceType": "",
  "featureSet": "",
  "defaultVersion": false,
  "nextToken": "",
  "maxResults": 0
}'

echo '{
  "permissionArn": "",
  "permissionVersion": 0,
  "associationStatus": "",
  "resourceType": "",
  "featureSet": "",
  "defaultVersion": false,
  "nextToken": "",
  "maxResults": 0
}' |  \
  http POST {{baseUrl}}/listpermissionassociations \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "permissionArn": "",\n  "permissionVersion": 0,\n  "associationStatus": "",\n  "resourceType": "",\n  "featureSet": "",\n  "defaultVersion": false,\n  "nextToken": "",\n  "maxResults": 0\n}' \
  --output-document \
  - {{baseUrl}}/listpermissionassociations

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "permissionArn": "",
  "permissionVersion": 0,
  "associationStatus": "",
  "resourceType": "",
  "featureSet": "",
  "defaultVersion": false,
  "nextToken": "",
  "maxResults": 0
] as [String : Any]

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

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

{{baseUrl}}/listpermissionversions

BODY json

{
  "permissionArn": "",
  "nextToken": "",
  "maxResults": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listpermissionversions");

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  \"permissionArn\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/listpermissionversions" {:content-type :json
                                                                   :form-params {:permissionArn ""
                                                                                 :nextToken ""
                                                                                 :maxResults 0}})

require "http/client"

url = "{{baseUrl}}/listpermissionversions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"permissionArn\": \"\",\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}}/listpermissionversions"),
    Content = new StringContent("{\n  \"permissionArn\": \"\",\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}}/listpermissionversions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"permissionArn\": \"\",\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}}/listpermissionversions"

	payload := strings.NewReader("{\n  \"permissionArn\": \"\",\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/listpermissionversions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 63

{
  "permissionArn": "",
  "nextToken": "",
  "maxResults": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/listpermissionversions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"permissionArn\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listpermissionversions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"permissionArn\": \"\",\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  \"permissionArn\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/listpermissionversions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/listpermissionversions")
  .header("content-type", "application/json")
  .body("{\n  \"permissionArn\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
  .asString();

const data = JSON.stringify({
  permissionArn: '',
  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}}/listpermissionversions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listpermissionversions',
  headers: {'content-type': 'application/json'},
  data: {permissionArn: '', nextToken: '', maxResults: 0}
};

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

const url = '{{baseUrl}}/listpermissionversions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"permissionArn":"","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}}/listpermissionversions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "permissionArn": "",\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  \"permissionArn\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/listpermissionversions")
  .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/listpermissionversions',
  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({permissionArn: '', nextToken: '', maxResults: 0}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listpermissionversions',
  headers: {'content-type': 'application/json'},
  body: {permissionArn: '', 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}}/listpermissionversions');

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

req.type('json');
req.send({
  permissionArn: '',
  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}}/listpermissionversions',
  headers: {'content-type': 'application/json'},
  data: {permissionArn: '', 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}}/listpermissionversions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"permissionArn":"","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 = @{ @"permissionArn": @"",
                              @"nextToken": @"",
                              @"maxResults": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/listpermissionversions"]
                                                       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}}/listpermissionversions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"permissionArn\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}" in

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

 "{{baseUrl}}/listpermissionversions",
  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([
    'permissionArn' => '',
    '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}}/listpermissionversions', [
  'body' => '{
  "permissionArn": "",
  "nextToken": "",
  "maxResults": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/listpermissionversions');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'permissionArn' => '',
  'nextToken' => '',
  'maxResults' => 0
]));

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

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

append(json_encode([
  'permissionArn' => '',
  'nextToken' => '',
  'maxResults' => 0
]));
$request->setRequestUrl('{{baseUrl}}/listpermissionversions');
$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}}/listpermissionversions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "permissionArn": "",
  "nextToken": "",
  "maxResults": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/listpermissionversions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "permissionArn": "",
  "nextToken": "",
  "maxResults": 0
}'

import http.client

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

payload = "{\n  \"permissionArn\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/listpermissionversions"

payload = {
    "permissionArn": "",
    "nextToken": "",
    "maxResults": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/listpermissionversions"

payload <- "{\n  \"permissionArn\": \"\",\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}}/listpermissionversions")

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  \"permissionArn\": \"\",\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/listpermissionversions') do |req|
  req.body = "{\n  \"permissionArn\": \"\",\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}}/listpermissionversions";

    let payload = json!({
        "permissionArn": "",
        "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}}/listpermissionversions \
  --header 'content-type: application/json' \
  --data '{
  "permissionArn": "",
  "nextToken": "",
  "maxResults": 0
}'

echo '{
  "permissionArn": "",
  "nextToken": "",
  "maxResults": 0
}' |  \
  http POST {{baseUrl}}/listpermissionversions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "permissionArn": "",\n  "nextToken": "",\n  "maxResults": 0\n}' \
  --output-document \
  - {{baseUrl}}/listpermissionversions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "permissionArn": "",
  "nextToken": "",
  "maxResults": 0
] as [String : Any]

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

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

{{baseUrl}}/listpermissions

BODY json

{
  "resourceType": "",
  "nextToken": "",
  "maxResults": 0,
  "permissionType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listpermissions");

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  \"resourceType\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/listpermissions" {:content-type :json
                                                            :form-params {:resourceType ""
                                                                          :nextToken ""
                                                                          :maxResults 0
                                                                          :permissionType ""}})

require "http/client"

url = "{{baseUrl}}/listpermissions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"resourceType\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionType\": \"\"\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}}/listpermissions"),
    Content = new StringContent("{\n  \"resourceType\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionType\": \"\"\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}}/listpermissions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"resourceType\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/listpermissions"

	payload := strings.NewReader("{\n  \"resourceType\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionType\": \"\"\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/listpermissions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 86

{
  "resourceType": "",
  "nextToken": "",
  "maxResults": 0,
  "permissionType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/listpermissions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"resourceType\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listpermissions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"resourceType\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionType\": \"\"\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  \"resourceType\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/listpermissions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/listpermissions")
  .header("content-type", "application/json")
  .body("{\n  \"resourceType\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  resourceType: '',
  nextToken: '',
  maxResults: 0,
  permissionType: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listpermissions',
  headers: {'content-type': 'application/json'},
  data: {resourceType: '', nextToken: '', maxResults: 0, permissionType: ''}
};

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

const url = '{{baseUrl}}/listpermissions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceType":"","nextToken":"","maxResults":0,"permissionType":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/listpermissions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "resourceType": "",\n  "nextToken": "",\n  "maxResults": 0,\n  "permissionType": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"resourceType\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/listpermissions")
  .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/listpermissions',
  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({resourceType: '', nextToken: '', maxResults: 0, permissionType: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listpermissions',
  headers: {'content-type': 'application/json'},
  body: {resourceType: '', nextToken: '', maxResults: 0, permissionType: ''},
  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}}/listpermissions');

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

req.type('json');
req.send({
  resourceType: '',
  nextToken: '',
  maxResults: 0,
  permissionType: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listpermissions',
  headers: {'content-type': 'application/json'},
  data: {resourceType: '', nextToken: '', maxResults: 0, permissionType: ''}
};

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

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

const url = '{{baseUrl}}/listpermissions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceType":"","nextToken":"","maxResults":0,"permissionType":""}'
};

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 = @{ @"resourceType": @"",
                              @"nextToken": @"",
                              @"maxResults": @0,
                              @"permissionType": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/listpermissions"]
                                                       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}}/listpermissions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"resourceType\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionType\": \"\"\n}" in

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

 "{{baseUrl}}/listpermissions",
  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([
    'resourceType' => '',
    'nextToken' => '',
    'maxResults' => 0,
    'permissionType' => ''
  ]),
  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}}/listpermissions', [
  'body' => '{
  "resourceType": "",
  "nextToken": "",
  "maxResults": 0,
  "permissionType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/listpermissions');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'resourceType' => '',
  'nextToken' => '',
  'maxResults' => 0,
  'permissionType' => ''
]));

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

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

append(json_encode([
  'resourceType' => '',
  'nextToken' => '',
  'maxResults' => 0,
  'permissionType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/listpermissions');
$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}}/listpermissions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceType": "",
  "nextToken": "",
  "maxResults": 0,
  "permissionType": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/listpermissions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceType": "",
  "nextToken": "",
  "maxResults": 0,
  "permissionType": ""
}'

import http.client

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

payload = "{\n  \"resourceType\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionType\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/listpermissions"

payload = {
    "resourceType": "",
    "nextToken": "",
    "maxResults": 0,
    "permissionType": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/listpermissions"

payload <- "{\n  \"resourceType\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionType\": \"\"\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}}/listpermissions")

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  \"resourceType\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionType\": \"\"\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/listpermissions') do |req|
  req.body = "{\n  \"resourceType\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"permissionType\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "resourceType": "",
        "nextToken": "",
        "maxResults": 0,
        "permissionType": ""
    });

    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}}/listpermissions \
  --header 'content-type: application/json' \
  --data '{
  "resourceType": "",
  "nextToken": "",
  "maxResults": 0,
  "permissionType": ""
}'

echo '{
  "resourceType": "",
  "nextToken": "",
  "maxResults": 0,
  "permissionType": ""
}' |  \
  http POST {{baseUrl}}/listpermissions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "resourceType": "",\n  "nextToken": "",\n  "maxResults": 0,\n  "permissionType": ""\n}' \
  --output-document \
  - {{baseUrl}}/listpermissions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "resourceType": "",
  "nextToken": "",
  "maxResults": 0,
  "permissionType": ""
] as [String : Any]

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

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

{{baseUrl}}/listprincipals

BODY json

{
  "resourceOwner": "",
  "resourceArn": "",
  "principals": [],
  "resourceType": "",
  "resourceShareArns": [],
  "nextToken": "",
  "maxResults": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listprincipals");

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  \"resourceOwner\": \"\",\n  \"resourceArn\": \"\",\n  \"principals\": [],\n  \"resourceType\": \"\",\n  \"resourceShareArns\": [],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/listprincipals" {:content-type :json
                                                           :form-params {:resourceOwner ""
                                                                         :resourceArn ""
                                                                         :principals []
                                                                         :resourceType ""
                                                                         :resourceShareArns []
                                                                         :nextToken ""
                                                                         :maxResults 0}})

require "http/client"

url = "{{baseUrl}}/listprincipals"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"resourceOwner\": \"\",\n  \"resourceArn\": \"\",\n  \"principals\": [],\n  \"resourceType\": \"\",\n  \"resourceShareArns\": [],\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}}/listprincipals"),
    Content = new StringContent("{\n  \"resourceOwner\": \"\",\n  \"resourceArn\": \"\",\n  \"principals\": [],\n  \"resourceType\": \"\",\n  \"resourceShareArns\": [],\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}}/listprincipals");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"resourceOwner\": \"\",\n  \"resourceArn\": \"\",\n  \"principals\": [],\n  \"resourceType\": \"\",\n  \"resourceShareArns\": [],\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}}/listprincipals"

	payload := strings.NewReader("{\n  \"resourceOwner\": \"\",\n  \"resourceArn\": \"\",\n  \"principals\": [],\n  \"resourceType\": \"\",\n  \"resourceShareArns\": [],\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/listprincipals HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 153

{
  "resourceOwner": "",
  "resourceArn": "",
  "principals": [],
  "resourceType": "",
  "resourceShareArns": [],
  "nextToken": "",
  "maxResults": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/listprincipals")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"resourceOwner\": \"\",\n  \"resourceArn\": \"\",\n  \"principals\": [],\n  \"resourceType\": \"\",\n  \"resourceShareArns\": [],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listprincipals"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"resourceOwner\": \"\",\n  \"resourceArn\": \"\",\n  \"principals\": [],\n  \"resourceType\": \"\",\n  \"resourceShareArns\": [],\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  \"resourceOwner\": \"\",\n  \"resourceArn\": \"\",\n  \"principals\": [],\n  \"resourceType\": \"\",\n  \"resourceShareArns\": [],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/listprincipals")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/listprincipals")
  .header("content-type", "application/json")
  .body("{\n  \"resourceOwner\": \"\",\n  \"resourceArn\": \"\",\n  \"principals\": [],\n  \"resourceType\": \"\",\n  \"resourceShareArns\": [],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
  .asString();

const data = JSON.stringify({
  resourceOwner: '',
  resourceArn: '',
  principals: [],
  resourceType: '',
  resourceShareArns: [],
  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}}/listprincipals');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listprincipals',
  headers: {'content-type': 'application/json'},
  data: {
    resourceOwner: '',
    resourceArn: '',
    principals: [],
    resourceType: '',
    resourceShareArns: [],
    nextToken: '',
    maxResults: 0
  }
};

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

const url = '{{baseUrl}}/listprincipals';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceOwner":"","resourceArn":"","principals":[],"resourceType":"","resourceShareArns":[],"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}}/listprincipals',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "resourceOwner": "",\n  "resourceArn": "",\n  "principals": [],\n  "resourceType": "",\n  "resourceShareArns": [],\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  \"resourceOwner\": \"\",\n  \"resourceArn\": \"\",\n  \"principals\": [],\n  \"resourceType\": \"\",\n  \"resourceShareArns\": [],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/listprincipals")
  .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/listprincipals',
  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({
  resourceOwner: '',
  resourceArn: '',
  principals: [],
  resourceType: '',
  resourceShareArns: [],
  nextToken: '',
  maxResults: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listprincipals',
  headers: {'content-type': 'application/json'},
  body: {
    resourceOwner: '',
    resourceArn: '',
    principals: [],
    resourceType: '',
    resourceShareArns: [],
    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}}/listprincipals');

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

req.type('json');
req.send({
  resourceOwner: '',
  resourceArn: '',
  principals: [],
  resourceType: '',
  resourceShareArns: [],
  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}}/listprincipals',
  headers: {'content-type': 'application/json'},
  data: {
    resourceOwner: '',
    resourceArn: '',
    principals: [],
    resourceType: '',
    resourceShareArns: [],
    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}}/listprincipals';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceOwner":"","resourceArn":"","principals":[],"resourceType":"","resourceShareArns":[],"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 = @{ @"resourceOwner": @"",
                              @"resourceArn": @"",
                              @"principals": @[  ],
                              @"resourceType": @"",
                              @"resourceShareArns": @[  ],
                              @"nextToken": @"",
                              @"maxResults": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/listprincipals"]
                                                       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}}/listprincipals" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"resourceOwner\": \"\",\n  \"resourceArn\": \"\",\n  \"principals\": [],\n  \"resourceType\": \"\",\n  \"resourceShareArns\": [],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}" in

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

 "{{baseUrl}}/listprincipals",
  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([
    'resourceOwner' => '',
    'resourceArn' => '',
    'principals' => [
        
    ],
    'resourceType' => '',
    'resourceShareArns' => [
        
    ],
    '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}}/listprincipals', [
  'body' => '{
  "resourceOwner": "",
  "resourceArn": "",
  "principals": [],
  "resourceType": "",
  "resourceShareArns": [],
  "nextToken": "",
  "maxResults": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/listprincipals');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'resourceOwner' => '',
  'resourceArn' => '',
  'principals' => [
    
  ],
  'resourceType' => '',
  'resourceShareArns' => [
    
  ],
  'nextToken' => '',
  'maxResults' => 0
]));

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

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

append(json_encode([
  'resourceOwner' => '',
  'resourceArn' => '',
  'principals' => [
    
  ],
  'resourceType' => '',
  'resourceShareArns' => [
    
  ],
  'nextToken' => '',
  'maxResults' => 0
]));
$request->setRequestUrl('{{baseUrl}}/listprincipals');
$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}}/listprincipals' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceOwner": "",
  "resourceArn": "",
  "principals": [],
  "resourceType": "",
  "resourceShareArns": [],
  "nextToken": "",
  "maxResults": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/listprincipals' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceOwner": "",
  "resourceArn": "",
  "principals": [],
  "resourceType": "",
  "resourceShareArns": [],
  "nextToken": "",
  "maxResults": 0
}'

import http.client

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

payload = "{\n  \"resourceOwner\": \"\",\n  \"resourceArn\": \"\",\n  \"principals\": [],\n  \"resourceType\": \"\",\n  \"resourceShareArns\": [],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/listprincipals"

payload = {
    "resourceOwner": "",
    "resourceArn": "",
    "principals": [],
    "resourceType": "",
    "resourceShareArns": [],
    "nextToken": "",
    "maxResults": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/listprincipals"

payload <- "{\n  \"resourceOwner\": \"\",\n  \"resourceArn\": \"\",\n  \"principals\": [],\n  \"resourceType\": \"\",\n  \"resourceShareArns\": [],\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}}/listprincipals")

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  \"resourceOwner\": \"\",\n  \"resourceArn\": \"\",\n  \"principals\": [],\n  \"resourceType\": \"\",\n  \"resourceShareArns\": [],\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/listprincipals') do |req|
  req.body = "{\n  \"resourceOwner\": \"\",\n  \"resourceArn\": \"\",\n  \"principals\": [],\n  \"resourceType\": \"\",\n  \"resourceShareArns\": [],\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}}/listprincipals";

    let payload = json!({
        "resourceOwner": "",
        "resourceArn": "",
        "principals": (),
        "resourceType": "",
        "resourceShareArns": (),
        "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}}/listprincipals \
  --header 'content-type: application/json' \
  --data '{
  "resourceOwner": "",
  "resourceArn": "",
  "principals": [],
  "resourceType": "",
  "resourceShareArns": [],
  "nextToken": "",
  "maxResults": 0
}'

echo '{
  "resourceOwner": "",
  "resourceArn": "",
  "principals": [],
  "resourceType": "",
  "resourceShareArns": [],
  "nextToken": "",
  "maxResults": 0
}' |  \
  http POST {{baseUrl}}/listprincipals \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "resourceOwner": "",\n  "resourceArn": "",\n  "principals": [],\n  "resourceType": "",\n  "resourceShareArns": [],\n  "nextToken": "",\n  "maxResults": 0\n}' \
  --output-document \
  - {{baseUrl}}/listprincipals

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "resourceOwner": "",
  "resourceArn": "",
  "principals": [],
  "resourceType": "",
  "resourceShareArns": [],
  "nextToken": "",
  "maxResults": 0
] as [String : Any]

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

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

{{baseUrl}}/listreplacepermissionassociationswork

BODY json

{
  "workIds": [],
  "status": "",
  "nextToken": "",
  "maxResults": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listreplacepermissionassociationswork");

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  \"workIds\": [],\n  \"status\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/listreplacepermissionassociationswork" {:content-type :json
                                                                                  :form-params {:workIds []
                                                                                                :status ""
                                                                                                :nextToken ""
                                                                                                :maxResults 0}})

require "http/client"

url = "{{baseUrl}}/listreplacepermissionassociationswork"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"workIds\": [],\n  \"status\": \"\",\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}}/listreplacepermissionassociationswork"),
    Content = new StringContent("{\n  \"workIds\": [],\n  \"status\": \"\",\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}}/listreplacepermissionassociationswork");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"workIds\": [],\n  \"status\": \"\",\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}}/listreplacepermissionassociationswork"

	payload := strings.NewReader("{\n  \"workIds\": [],\n  \"status\": \"\",\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/listreplacepermissionassociationswork HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 73

{
  "workIds": [],
  "status": "",
  "nextToken": "",
  "maxResults": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/listreplacepermissionassociationswork")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"workIds\": [],\n  \"status\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listreplacepermissionassociationswork"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"workIds\": [],\n  \"status\": \"\",\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  \"workIds\": [],\n  \"status\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/listreplacepermissionassociationswork")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/listreplacepermissionassociationswork")
  .header("content-type", "application/json")
  .body("{\n  \"workIds\": [],\n  \"status\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
  .asString();

const data = JSON.stringify({
  workIds: [],
  status: '',
  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}}/listreplacepermissionassociationswork');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listreplacepermissionassociationswork',
  headers: {'content-type': 'application/json'},
  data: {workIds: [], status: '', nextToken: '', maxResults: 0}
};

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

const url = '{{baseUrl}}/listreplacepermissionassociationswork';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"workIds":[],"status":"","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}}/listreplacepermissionassociationswork',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "workIds": [],\n  "status": "",\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  \"workIds\": [],\n  \"status\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/listreplacepermissionassociationswork")
  .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/listreplacepermissionassociationswork',
  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({workIds: [], status: '', nextToken: '', maxResults: 0}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listreplacepermissionassociationswork',
  headers: {'content-type': 'application/json'},
  body: {workIds: [], status: '', 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}}/listreplacepermissionassociationswork');

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

req.type('json');
req.send({
  workIds: [],
  status: '',
  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}}/listreplacepermissionassociationswork',
  headers: {'content-type': 'application/json'},
  data: {workIds: [], status: '', 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}}/listreplacepermissionassociationswork';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"workIds":[],"status":"","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 = @{ @"workIds": @[  ],
                              @"status": @"",
                              @"nextToken": @"",
                              @"maxResults": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/listreplacepermissionassociationswork"]
                                                       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}}/listreplacepermissionassociationswork" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"workIds\": [],\n  \"status\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}" in

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

 "{{baseUrl}}/listreplacepermissionassociationswork",
  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([
    'workIds' => [
        
    ],
    'status' => '',
    '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}}/listreplacepermissionassociationswork', [
  'body' => '{
  "workIds": [],
  "status": "",
  "nextToken": "",
  "maxResults": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/listreplacepermissionassociationswork');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'workIds' => [
    
  ],
  'status' => '',
  'nextToken' => '',
  'maxResults' => 0
]));

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

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

append(json_encode([
  'workIds' => [
    
  ],
  'status' => '',
  'nextToken' => '',
  'maxResults' => 0
]));
$request->setRequestUrl('{{baseUrl}}/listreplacepermissionassociationswork');
$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}}/listreplacepermissionassociationswork' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "workIds": [],
  "status": "",
  "nextToken": "",
  "maxResults": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/listreplacepermissionassociationswork' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "workIds": [],
  "status": "",
  "nextToken": "",
  "maxResults": 0
}'

import http.client

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

payload = "{\n  \"workIds\": [],\n  \"status\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/listreplacepermissionassociationswork"

payload = {
    "workIds": [],
    "status": "",
    "nextToken": "",
    "maxResults": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/listreplacepermissionassociationswork"

payload <- "{\n  \"workIds\": [],\n  \"status\": \"\",\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}}/listreplacepermissionassociationswork")

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  \"workIds\": [],\n  \"status\": \"\",\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/listreplacepermissionassociationswork') do |req|
  req.body = "{\n  \"workIds\": [],\n  \"status\": \"\",\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}}/listreplacepermissionassociationswork";

    let payload = json!({
        "workIds": (),
        "status": "",
        "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}}/listreplacepermissionassociationswork \
  --header 'content-type: application/json' \
  --data '{
  "workIds": [],
  "status": "",
  "nextToken": "",
  "maxResults": 0
}'

echo '{
  "workIds": [],
  "status": "",
  "nextToken": "",
  "maxResults": 0
}' |  \
  http POST {{baseUrl}}/listreplacepermissionassociationswork \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "workIds": [],\n  "status": "",\n  "nextToken": "",\n  "maxResults": 0\n}' \
  --output-document \
  - {{baseUrl}}/listreplacepermissionassociationswork

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "workIds": [],
  "status": "",
  "nextToken": "",
  "maxResults": 0
] as [String : Any]

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

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

{{baseUrl}}/listresourcesharepermissions

BODY json

{
  "resourceShareArn": "",
  "nextToken": "",
  "maxResults": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listresourcesharepermissions");

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  \"resourceShareArn\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/listresourcesharepermissions" {:content-type :json
                                                                         :form-params {:resourceShareArn ""
                                                                                       :nextToken ""
                                                                                       :maxResults 0}})

require "http/client"

url = "{{baseUrl}}/listresourcesharepermissions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"resourceShareArn\": \"\",\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}}/listresourcesharepermissions"),
    Content = new StringContent("{\n  \"resourceShareArn\": \"\",\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}}/listresourcesharepermissions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"resourceShareArn\": \"\",\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}}/listresourcesharepermissions"

	payload := strings.NewReader("{\n  \"resourceShareArn\": \"\",\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/listresourcesharepermissions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 66

{
  "resourceShareArn": "",
  "nextToken": "",
  "maxResults": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/listresourcesharepermissions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"resourceShareArn\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listresourcesharepermissions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"resourceShareArn\": \"\",\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  \"resourceShareArn\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/listresourcesharepermissions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/listresourcesharepermissions")
  .header("content-type", "application/json")
  .body("{\n  \"resourceShareArn\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
  .asString();

const data = JSON.stringify({
  resourceShareArn: '',
  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}}/listresourcesharepermissions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listresourcesharepermissions',
  headers: {'content-type': 'application/json'},
  data: {resourceShareArn: '', nextToken: '', maxResults: 0}
};

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

const url = '{{baseUrl}}/listresourcesharepermissions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceShareArn":"","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}}/listresourcesharepermissions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "resourceShareArn": "",\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  \"resourceShareArn\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/listresourcesharepermissions")
  .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/listresourcesharepermissions',
  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({resourceShareArn: '', nextToken: '', maxResults: 0}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listresourcesharepermissions',
  headers: {'content-type': 'application/json'},
  body: {resourceShareArn: '', 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}}/listresourcesharepermissions');

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

req.type('json');
req.send({
  resourceShareArn: '',
  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}}/listresourcesharepermissions',
  headers: {'content-type': 'application/json'},
  data: {resourceShareArn: '', 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}}/listresourcesharepermissions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceShareArn":"","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 = @{ @"resourceShareArn": @"",
                              @"nextToken": @"",
                              @"maxResults": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/listresourcesharepermissions"]
                                                       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}}/listresourcesharepermissions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"resourceShareArn\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}" in

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

 "{{baseUrl}}/listresourcesharepermissions",
  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([
    'resourceShareArn' => '',
    '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}}/listresourcesharepermissions', [
  'body' => '{
  "resourceShareArn": "",
  "nextToken": "",
  "maxResults": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/listresourcesharepermissions');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'resourceShareArn' => '',
  'nextToken' => '',
  'maxResults' => 0
]));

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

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

append(json_encode([
  'resourceShareArn' => '',
  'nextToken' => '',
  'maxResults' => 0
]));
$request->setRequestUrl('{{baseUrl}}/listresourcesharepermissions');
$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}}/listresourcesharepermissions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceShareArn": "",
  "nextToken": "",
  "maxResults": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/listresourcesharepermissions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceShareArn": "",
  "nextToken": "",
  "maxResults": 0
}'

import http.client

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

payload = "{\n  \"resourceShareArn\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/listresourcesharepermissions"

payload = {
    "resourceShareArn": "",
    "nextToken": "",
    "maxResults": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/listresourcesharepermissions"

payload <- "{\n  \"resourceShareArn\": \"\",\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}}/listresourcesharepermissions")

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  \"resourceShareArn\": \"\",\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/listresourcesharepermissions') do |req|
  req.body = "{\n  \"resourceShareArn\": \"\",\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}}/listresourcesharepermissions";

    let payload = json!({
        "resourceShareArn": "",
        "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}}/listresourcesharepermissions \
  --header 'content-type: application/json' \
  --data '{
  "resourceShareArn": "",
  "nextToken": "",
  "maxResults": 0
}'

echo '{
  "resourceShareArn": "",
  "nextToken": "",
  "maxResults": 0
}' |  \
  http POST {{baseUrl}}/listresourcesharepermissions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "resourceShareArn": "",\n  "nextToken": "",\n  "maxResults": 0\n}' \
  --output-document \
  - {{baseUrl}}/listresourcesharepermissions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "resourceShareArn": "",
  "nextToken": "",
  "maxResults": 0
] as [String : Any]

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

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

{{baseUrl}}/listresourcetypes

BODY json

{
  "nextToken": "",
  "maxResults": 0,
  "resourceRegionScope": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listresourcetypes");

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  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/listresourcetypes" {:content-type :json
                                                              :form-params {:nextToken ""
                                                                            :maxResults 0
                                                                            :resourceRegionScope ""}})

require "http/client"

url = "{{baseUrl}}/listresourcetypes"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\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}}/listresourcetypes"),
    Content = new StringContent("{\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\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}}/listresourcetypes");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/listresourcetypes"

	payload := strings.NewReader("{\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\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/listresourcetypes HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 69

{
  "nextToken": "",
  "maxResults": 0,
  "resourceRegionScope": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/listresourcetypes")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listresourcetypes"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\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  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/listresourcetypes")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/listresourcetypes")
  .header("content-type", "application/json")
  .body("{\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  nextToken: '',
  maxResults: 0,
  resourceRegionScope: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listresourcetypes',
  headers: {'content-type': 'application/json'},
  data: {nextToken: '', maxResults: 0, resourceRegionScope: ''}
};

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

const url = '{{baseUrl}}/listresourcetypes';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"nextToken":"","maxResults":0,"resourceRegionScope":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/listresourcetypes',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "nextToken": "",\n  "maxResults": 0,\n  "resourceRegionScope": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/listresourcetypes")
  .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/listresourcetypes',
  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({nextToken: '', maxResults: 0, resourceRegionScope: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listresourcetypes',
  headers: {'content-type': 'application/json'},
  body: {nextToken: '', maxResults: 0, resourceRegionScope: ''},
  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}}/listresourcetypes');

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

req.type('json');
req.send({
  nextToken: '',
  maxResults: 0,
  resourceRegionScope: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listresourcetypes',
  headers: {'content-type': 'application/json'},
  data: {nextToken: '', maxResults: 0, resourceRegionScope: ''}
};

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

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

const url = '{{baseUrl}}/listresourcetypes';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"nextToken":"","maxResults":0,"resourceRegionScope":""}'
};

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 = @{ @"nextToken": @"",
                              @"maxResults": @0,
                              @"resourceRegionScope": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/listresourcetypes"]
                                                       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}}/listresourcetypes" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\n}" in

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

 "{{baseUrl}}/listresourcetypes",
  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([
    'nextToken' => '',
    'maxResults' => 0,
    'resourceRegionScope' => ''
  ]),
  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}}/listresourcetypes', [
  'body' => '{
  "nextToken": "",
  "maxResults": 0,
  "resourceRegionScope": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/listresourcetypes');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'nextToken' => '',
  'maxResults' => 0,
  'resourceRegionScope' => ''
]));

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

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

append(json_encode([
  'nextToken' => '',
  'maxResults' => 0,
  'resourceRegionScope' => ''
]));
$request->setRequestUrl('{{baseUrl}}/listresourcetypes');
$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}}/listresourcetypes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "nextToken": "",
  "maxResults": 0,
  "resourceRegionScope": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/listresourcetypes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "nextToken": "",
  "maxResults": 0,
  "resourceRegionScope": ""
}'

import http.client

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

payload = "{\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/listresourcetypes"

payload = {
    "nextToken": "",
    "maxResults": 0,
    "resourceRegionScope": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/listresourcetypes"

payload <- "{\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\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}}/listresourcetypes")

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  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\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/listresourcetypes') do |req|
  req.body = "{\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "nextToken": "",
        "maxResults": 0,
        "resourceRegionScope": ""
    });

    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}}/listresourcetypes \
  --header 'content-type: application/json' \
  --data '{
  "nextToken": "",
  "maxResults": 0,
  "resourceRegionScope": ""
}'

echo '{
  "nextToken": "",
  "maxResults": 0,
  "resourceRegionScope": ""
}' |  \
  http POST {{baseUrl}}/listresourcetypes \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "nextToken": "",\n  "maxResults": 0,\n  "resourceRegionScope": ""\n}' \
  --output-document \
  - {{baseUrl}}/listresourcetypes

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "nextToken": "",
  "maxResults": 0,
  "resourceRegionScope": ""
] as [String : Any]

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

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

{{baseUrl}}/listresources

BODY json

{
  "resourceOwner": "",
  "principal": "",
  "resourceType": "",
  "resourceArns": [],
  "resourceShareArns": [],
  "nextToken": "",
  "maxResults": 0,
  "resourceRegionScope": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listresources");

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  \"resourceOwner\": \"\",\n  \"principal\": \"\",\n  \"resourceType\": \"\",\n  \"resourceArns\": [],\n  \"resourceShareArns\": [],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/listresources" {:content-type :json
                                                          :form-params {:resourceOwner ""
                                                                        :principal ""
                                                                        :resourceType ""
                                                                        :resourceArns []
                                                                        :resourceShareArns []
                                                                        :nextToken ""
                                                                        :maxResults 0
                                                                        :resourceRegionScope ""}})

require "http/client"

url = "{{baseUrl}}/listresources"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"resourceOwner\": \"\",\n  \"principal\": \"\",\n  \"resourceType\": \"\",\n  \"resourceArns\": [],\n  \"resourceShareArns\": [],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\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}}/listresources"),
    Content = new StringContent("{\n  \"resourceOwner\": \"\",\n  \"principal\": \"\",\n  \"resourceType\": \"\",\n  \"resourceArns\": [],\n  \"resourceShareArns\": [],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\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}}/listresources");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"resourceOwner\": \"\",\n  \"principal\": \"\",\n  \"resourceType\": \"\",\n  \"resourceArns\": [],\n  \"resourceShareArns\": [],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/listresources"

	payload := strings.NewReader("{\n  \"resourceOwner\": \"\",\n  \"principal\": \"\",\n  \"resourceType\": \"\",\n  \"resourceArns\": [],\n  \"resourceShareArns\": [],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\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/listresources HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 182

{
  "resourceOwner": "",
  "principal": "",
  "resourceType": "",
  "resourceArns": [],
  "resourceShareArns": [],
  "nextToken": "",
  "maxResults": 0,
  "resourceRegionScope": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/listresources")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"resourceOwner\": \"\",\n  \"principal\": \"\",\n  \"resourceType\": \"\",\n  \"resourceArns\": [],\n  \"resourceShareArns\": [],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/listresources"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"resourceOwner\": \"\",\n  \"principal\": \"\",\n  \"resourceType\": \"\",\n  \"resourceArns\": [],\n  \"resourceShareArns\": [],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\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  \"resourceOwner\": \"\",\n  \"principal\": \"\",\n  \"resourceType\": \"\",\n  \"resourceArns\": [],\n  \"resourceShareArns\": [],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/listresources")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/listresources")
  .header("content-type", "application/json")
  .body("{\n  \"resourceOwner\": \"\",\n  \"principal\": \"\",\n  \"resourceType\": \"\",\n  \"resourceArns\": [],\n  \"resourceShareArns\": [],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  resourceOwner: '',
  principal: '',
  resourceType: '',
  resourceArns: [],
  resourceShareArns: [],
  nextToken: '',
  maxResults: 0,
  resourceRegionScope: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listresources',
  headers: {'content-type': 'application/json'},
  data: {
    resourceOwner: '',
    principal: '',
    resourceType: '',
    resourceArns: [],
    resourceShareArns: [],
    nextToken: '',
    maxResults: 0,
    resourceRegionScope: ''
  }
};

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

const url = '{{baseUrl}}/listresources';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceOwner":"","principal":"","resourceType":"","resourceArns":[],"resourceShareArns":[],"nextToken":"","maxResults":0,"resourceRegionScope":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/listresources',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "resourceOwner": "",\n  "principal": "",\n  "resourceType": "",\n  "resourceArns": [],\n  "resourceShareArns": [],\n  "nextToken": "",\n  "maxResults": 0,\n  "resourceRegionScope": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"resourceOwner\": \"\",\n  \"principal\": \"\",\n  \"resourceType\": \"\",\n  \"resourceArns\": [],\n  \"resourceShareArns\": [],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/listresources")
  .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/listresources',
  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({
  resourceOwner: '',
  principal: '',
  resourceType: '',
  resourceArns: [],
  resourceShareArns: [],
  nextToken: '',
  maxResults: 0,
  resourceRegionScope: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listresources',
  headers: {'content-type': 'application/json'},
  body: {
    resourceOwner: '',
    principal: '',
    resourceType: '',
    resourceArns: [],
    resourceShareArns: [],
    nextToken: '',
    maxResults: 0,
    resourceRegionScope: ''
  },
  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}}/listresources');

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

req.type('json');
req.send({
  resourceOwner: '',
  principal: '',
  resourceType: '',
  resourceArns: [],
  resourceShareArns: [],
  nextToken: '',
  maxResults: 0,
  resourceRegionScope: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/listresources',
  headers: {'content-type': 'application/json'},
  data: {
    resourceOwner: '',
    principal: '',
    resourceType: '',
    resourceArns: [],
    resourceShareArns: [],
    nextToken: '',
    maxResults: 0,
    resourceRegionScope: ''
  }
};

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

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

const url = '{{baseUrl}}/listresources';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceOwner":"","principal":"","resourceType":"","resourceArns":[],"resourceShareArns":[],"nextToken":"","maxResults":0,"resourceRegionScope":""}'
};

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 = @{ @"resourceOwner": @"",
                              @"principal": @"",
                              @"resourceType": @"",
                              @"resourceArns": @[  ],
                              @"resourceShareArns": @[  ],
                              @"nextToken": @"",
                              @"maxResults": @0,
                              @"resourceRegionScope": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/listresources"]
                                                       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}}/listresources" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"resourceOwner\": \"\",\n  \"principal\": \"\",\n  \"resourceType\": \"\",\n  \"resourceArns\": [],\n  \"resourceShareArns\": [],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\n}" in

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

 "{{baseUrl}}/listresources",
  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([
    'resourceOwner' => '',
    'principal' => '',
    'resourceType' => '',
    'resourceArns' => [
        
    ],
    'resourceShareArns' => [
        
    ],
    'nextToken' => '',
    'maxResults' => 0,
    'resourceRegionScope' => ''
  ]),
  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}}/listresources', [
  'body' => '{
  "resourceOwner": "",
  "principal": "",
  "resourceType": "",
  "resourceArns": [],
  "resourceShareArns": [],
  "nextToken": "",
  "maxResults": 0,
  "resourceRegionScope": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/listresources');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'resourceOwner' => '',
  'principal' => '',
  'resourceType' => '',
  'resourceArns' => [
    
  ],
  'resourceShareArns' => [
    
  ],
  'nextToken' => '',
  'maxResults' => 0,
  'resourceRegionScope' => ''
]));

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

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

append(json_encode([
  'resourceOwner' => '',
  'principal' => '',
  'resourceType' => '',
  'resourceArns' => [
    
  ],
  'resourceShareArns' => [
    
  ],
  'nextToken' => '',
  'maxResults' => 0,
  'resourceRegionScope' => ''
]));
$request->setRequestUrl('{{baseUrl}}/listresources');
$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}}/listresources' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceOwner": "",
  "principal": "",
  "resourceType": "",
  "resourceArns": [],
  "resourceShareArns": [],
  "nextToken": "",
  "maxResults": 0,
  "resourceRegionScope": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/listresources' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceOwner": "",
  "principal": "",
  "resourceType": "",
  "resourceArns": [],
  "resourceShareArns": [],
  "nextToken": "",
  "maxResults": 0,
  "resourceRegionScope": ""
}'

import http.client

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

payload = "{\n  \"resourceOwner\": \"\",\n  \"principal\": \"\",\n  \"resourceType\": \"\",\n  \"resourceArns\": [],\n  \"resourceShareArns\": [],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/listresources"

payload = {
    "resourceOwner": "",
    "principal": "",
    "resourceType": "",
    "resourceArns": [],
    "resourceShareArns": [],
    "nextToken": "",
    "maxResults": 0,
    "resourceRegionScope": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/listresources"

payload <- "{\n  \"resourceOwner\": \"\",\n  \"principal\": \"\",\n  \"resourceType\": \"\",\n  \"resourceArns\": [],\n  \"resourceShareArns\": [],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\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}}/listresources")

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  \"resourceOwner\": \"\",\n  \"principal\": \"\",\n  \"resourceType\": \"\",\n  \"resourceArns\": [],\n  \"resourceShareArns\": [],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\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/listresources') do |req|
  req.body = "{\n  \"resourceOwner\": \"\",\n  \"principal\": \"\",\n  \"resourceType\": \"\",\n  \"resourceArns\": [],\n  \"resourceShareArns\": [],\n  \"nextToken\": \"\",\n  \"maxResults\": 0,\n  \"resourceRegionScope\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "resourceOwner": "",
        "principal": "",
        "resourceType": "",
        "resourceArns": (),
        "resourceShareArns": (),
        "nextToken": "",
        "maxResults": 0,
        "resourceRegionScope": ""
    });

    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}}/listresources \
  --header 'content-type: application/json' \
  --data '{
  "resourceOwner": "",
  "principal": "",
  "resourceType": "",
  "resourceArns": [],
  "resourceShareArns": [],
  "nextToken": "",
  "maxResults": 0,
  "resourceRegionScope": ""
}'

echo '{
  "resourceOwner": "",
  "principal": "",
  "resourceType": "",
  "resourceArns": [],
  "resourceShareArns": [],
  "nextToken": "",
  "maxResults": 0,
  "resourceRegionScope": ""
}' |  \
  http POST {{baseUrl}}/listresources \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "resourceOwner": "",\n  "principal": "",\n  "resourceType": "",\n  "resourceArns": [],\n  "resourceShareArns": [],\n  "nextToken": "",\n  "maxResults": 0,\n  "resourceRegionScope": ""\n}' \
  --output-document \
  - {{baseUrl}}/listresources

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "resourceOwner": "",
  "principal": "",
  "resourceType": "",
  "resourceArns": [],
  "resourceShareArns": [],
  "nextToken": "",
  "maxResults": 0,
  "resourceRegionScope": ""
] as [String : Any]

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

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

{{baseUrl}}/promotepermissioncreatedfrompolicy

BODY json

{
  "permissionArn": "",
  "name": "",
  "clientToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/promotepermissioncreatedfrompolicy");

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  \"permissionArn\": \"\",\n  \"name\": \"\",\n  \"clientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/promotepermissioncreatedfrompolicy" {:content-type :json
                                                                               :form-params {:permissionArn ""
                                                                                             :name ""
                                                                                             :clientToken ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/promotepermissioncreatedfrompolicy"

	payload := strings.NewReader("{\n  \"permissionArn\": \"\",\n  \"name\": \"\",\n  \"clientToken\": \"\"\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/promotepermissioncreatedfrompolicy HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 60

{
  "permissionArn": "",
  "name": "",
  "clientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/promotepermissioncreatedfrompolicy")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"permissionArn\": \"\",\n  \"name\": \"\",\n  \"clientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/promotepermissioncreatedfrompolicy")
  .header("content-type", "application/json")
  .body("{\n  \"permissionArn\": \"\",\n  \"name\": \"\",\n  \"clientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  permissionArn: '',
  name: '',
  clientToken: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/promotepermissioncreatedfrompolicy',
  headers: {'content-type': 'application/json'},
  data: {permissionArn: '', name: '', clientToken: ''}
};

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

const url = '{{baseUrl}}/promotepermissioncreatedfrompolicy';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"permissionArn":"","name":"","clientToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/promotepermissioncreatedfrompolicy',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "permissionArn": "",\n  "name": "",\n  "clientToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"permissionArn\": \"\",\n  \"name\": \"\",\n  \"clientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/promotepermissioncreatedfrompolicy")
  .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/promotepermissioncreatedfrompolicy',
  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({permissionArn: '', name: '', clientToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/promotepermissioncreatedfrompolicy',
  headers: {'content-type': 'application/json'},
  body: {permissionArn: '', name: '', clientToken: ''},
  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}}/promotepermissioncreatedfrompolicy');

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

req.type('json');
req.send({
  permissionArn: '',
  name: '',
  clientToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/promotepermissioncreatedfrompolicy',
  headers: {'content-type': 'application/json'},
  data: {permissionArn: '', name: '', clientToken: ''}
};

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

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

const url = '{{baseUrl}}/promotepermissioncreatedfrompolicy';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"permissionArn":"","name":"","clientToken":""}'
};

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 = @{ @"permissionArn": @"",
                              @"name": @"",
                              @"clientToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/promotepermissioncreatedfrompolicy"]
                                                       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}}/promotepermissioncreatedfrompolicy" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"permissionArn\": \"\",\n  \"name\": \"\",\n  \"clientToken\": \"\"\n}" in

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

 "{{baseUrl}}/promotepermissioncreatedfrompolicy",
  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([
    'permissionArn' => '',
    'name' => '',
    'clientToken' => ''
  ]),
  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}}/promotepermissioncreatedfrompolicy', [
  'body' => '{
  "permissionArn": "",
  "name": "",
  "clientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/promotepermissioncreatedfrompolicy');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'permissionArn' => '',
  'name' => '',
  'clientToken' => ''
]));

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

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

append(json_encode([
  'permissionArn' => '',
  'name' => '',
  'clientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/promotepermissioncreatedfrompolicy');
$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}}/promotepermissioncreatedfrompolicy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "permissionArn": "",
  "name": "",
  "clientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/promotepermissioncreatedfrompolicy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "permissionArn": "",
  "name": "",
  "clientToken": ""
}'

import http.client

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

payload = "{\n  \"permissionArn\": \"\",\n  \"name\": \"\",\n  \"clientToken\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/promotepermissioncreatedfrompolicy"

payload = {
    "permissionArn": "",
    "name": "",
    "clientToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/promotepermissioncreatedfrompolicy"

payload <- "{\n  \"permissionArn\": \"\",\n  \"name\": \"\",\n  \"clientToken\": \"\"\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}}/promotepermissioncreatedfrompolicy")

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  \"permissionArn\": \"\",\n  \"name\": \"\",\n  \"clientToken\": \"\"\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/promotepermissioncreatedfrompolicy') do |req|
  req.body = "{\n  \"permissionArn\": \"\",\n  \"name\": \"\",\n  \"clientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "permissionArn": "",
        "name": "",
        "clientToken": ""
    });

    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}}/promotepermissioncreatedfrompolicy \
  --header 'content-type: application/json' \
  --data '{
  "permissionArn": "",
  "name": "",
  "clientToken": ""
}'

echo '{
  "permissionArn": "",
  "name": "",
  "clientToken": ""
}' |  \
  http POST {{baseUrl}}/promotepermissioncreatedfrompolicy \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "permissionArn": "",\n  "name": "",\n  "clientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/promotepermissioncreatedfrompolicy

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "permissionArn": "",
  "name": "",
  "clientToken": ""
] as [String : Any]

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

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

{{baseUrl}}/promoteresourcesharecreatedfrompolicy#resourceShareArn

QUERY PARAMS

resourceShareArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/promoteresourcesharecreatedfrompolicy?resourceShareArn=#resourceShareArn");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/promoteresourcesharecreatedfrompolicy#resourceShareArn" {:query-params {:resourceShareArn ""}})

require "http/client"

url = "{{baseUrl}}/promoteresourcesharecreatedfrompolicy?resourceShareArn=#resourceShareArn"

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}}/promoteresourcesharecreatedfrompolicy?resourceShareArn=#resourceShareArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/promoteresourcesharecreatedfrompolicy?resourceShareArn=#resourceShareArn");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/promoteresourcesharecreatedfrompolicy?resourceShareArn=#resourceShareArn"

	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/promoteresourcesharecreatedfrompolicy?resourceShareArn= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/promoteresourcesharecreatedfrompolicy?resourceShareArn=#resourceShareArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/promoteresourcesharecreatedfrompolicy?resourceShareArn=#resourceShareArn"))
    .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}}/promoteresourcesharecreatedfrompolicy?resourceShareArn=#resourceShareArn")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/promoteresourcesharecreatedfrompolicy?resourceShareArn=#resourceShareArn")
  .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}}/promoteresourcesharecreatedfrompolicy?resourceShareArn=#resourceShareArn');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/promoteresourcesharecreatedfrompolicy#resourceShareArn',
  params: {resourceShareArn: ''}
};

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

const url = '{{baseUrl}}/promoteresourcesharecreatedfrompolicy?resourceShareArn=#resourceShareArn';
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}}/promoteresourcesharecreatedfrompolicy?resourceShareArn=#resourceShareArn',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/promoteresourcesharecreatedfrompolicy?resourceShareArn=#resourceShareArn")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/promoteresourcesharecreatedfrompolicy?resourceShareArn=',
  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}}/promoteresourcesharecreatedfrompolicy#resourceShareArn',
  qs: {resourceShareArn: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/promoteresourcesharecreatedfrompolicy#resourceShareArn');

req.query({
  resourceShareArn: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/promoteresourcesharecreatedfrompolicy#resourceShareArn',
  params: {resourceShareArn: ''}
};

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

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

const url = '{{baseUrl}}/promoteresourcesharecreatedfrompolicy?resourceShareArn=#resourceShareArn';
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}}/promoteresourcesharecreatedfrompolicy?resourceShareArn=#resourceShareArn"]
                                                       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}}/promoteresourcesharecreatedfrompolicy?resourceShareArn=#resourceShareArn" in

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

 "{{baseUrl}}/promoteresourcesharecreatedfrompolicy?resourceShareArn=#resourceShareArn",
  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}}/promoteresourcesharecreatedfrompolicy?resourceShareArn=#resourceShareArn');

echo $response->getBody();

setUrl('{{baseUrl}}/promoteresourcesharecreatedfrompolicy#resourceShareArn');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'resourceShareArn' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/promoteresourcesharecreatedfrompolicy#resourceShareArn');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'resourceShareArn' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/promoteresourcesharecreatedfrompolicy?resourceShareArn=#resourceShareArn' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/promoteresourcesharecreatedfrompolicy?resourceShareArn=#resourceShareArn' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/promoteresourcesharecreatedfrompolicy?resourceShareArn=")

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

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

import requests

url = "{{baseUrl}}/promoteresourcesharecreatedfrompolicy#resourceShareArn"

querystring = {"resourceShareArn":""}

response = requests.post(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/promoteresourcesharecreatedfrompolicy#resourceShareArn"

queryString <- list(resourceShareArn = "")

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/promoteresourcesharecreatedfrompolicy?resourceShareArn=#resourceShareArn")

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/promoteresourcesharecreatedfrompolicy') do |req|
  req.params['resourceShareArn'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let querystring = [
        ("resourceShareArn", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/promoteresourcesharecreatedfrompolicy?resourceShareArn=#resourceShareArn'

http POST '{{baseUrl}}/promoteresourcesharecreatedfrompolicy?resourceShareArn=#resourceShareArn'

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/promoteresourcesharecreatedfrompolicy?resourceShareArn=#resourceShareArn'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/promoteresourcesharecreatedfrompolicy?resourceShareArn=#resourceShareArn")! 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 RejectResourceShareInvitation

{{baseUrl}}/rejectresourceshareinvitation

BODY json

{
  "resourceShareInvitationArn": "",
  "clientToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rejectresourceshareinvitation");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/rejectresourceshareinvitation" {:content-type :json
                                                                          :form-params {:resourceShareInvitationArn ""
                                                                                        :clientToken ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/rejectresourceshareinvitation"

	payload := strings.NewReader("{\n  \"resourceShareInvitationArn\": \"\",\n  \"clientToken\": \"\"\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/rejectresourceshareinvitation HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 59

{
  "resourceShareInvitationArn": "",
  "clientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/rejectresourceshareinvitation")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"resourceShareInvitationArn\": \"\",\n  \"clientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/rejectresourceshareinvitation")
  .header("content-type", "application/json")
  .body("{\n  \"resourceShareInvitationArn\": \"\",\n  \"clientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  resourceShareInvitationArn: '',
  clientToken: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rejectresourceshareinvitation',
  headers: {'content-type': 'application/json'},
  data: {resourceShareInvitationArn: '', clientToken: ''}
};

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

const url = '{{baseUrl}}/rejectresourceshareinvitation';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceShareInvitationArn":"","clientToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rejectresourceshareinvitation',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "resourceShareInvitationArn": "",\n  "clientToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"resourceShareInvitationArn\": \"\",\n  \"clientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/rejectresourceshareinvitation")
  .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/rejectresourceshareinvitation',
  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({resourceShareInvitationArn: '', clientToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rejectresourceshareinvitation',
  headers: {'content-type': 'application/json'},
  body: {resourceShareInvitationArn: '', clientToken: ''},
  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}}/rejectresourceshareinvitation');

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

req.type('json');
req.send({
  resourceShareInvitationArn: '',
  clientToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rejectresourceshareinvitation',
  headers: {'content-type': 'application/json'},
  data: {resourceShareInvitationArn: '', clientToken: ''}
};

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

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

const url = '{{baseUrl}}/rejectresourceshareinvitation';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceShareInvitationArn":"","clientToken":""}'
};

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

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

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

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

 "{{baseUrl}}/rejectresourceshareinvitation",
  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([
    'resourceShareInvitationArn' => '',
    'clientToken' => ''
  ]),
  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}}/rejectresourceshareinvitation', [
  'body' => '{
  "resourceShareInvitationArn": "",
  "clientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/rejectresourceshareinvitation');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'resourceShareInvitationArn' => '',
  'clientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/rejectresourceshareinvitation');
$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}}/rejectresourceshareinvitation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceShareInvitationArn": "",
  "clientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/rejectresourceshareinvitation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceShareInvitationArn": "",
  "clientToken": ""
}'

import http.client

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

payload = "{\n  \"resourceShareInvitationArn\": \"\",\n  \"clientToken\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/rejectresourceshareinvitation"

payload = {
    "resourceShareInvitationArn": "",
    "clientToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/rejectresourceshareinvitation"

payload <- "{\n  \"resourceShareInvitationArn\": \"\",\n  \"clientToken\": \"\"\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}}/rejectresourceshareinvitation")

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  \"resourceShareInvitationArn\": \"\",\n  \"clientToken\": \"\"\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/rejectresourceshareinvitation') do |req|
  req.body = "{\n  \"resourceShareInvitationArn\": \"\",\n  \"clientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "resourceShareInvitationArn": "",
        "clientToken": ""
    });

    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}}/rejectresourceshareinvitation \
  --header 'content-type: application/json' \
  --data '{
  "resourceShareInvitationArn": "",
  "clientToken": ""
}'

echo '{
  "resourceShareInvitationArn": "",
  "clientToken": ""
}' |  \
  http POST {{baseUrl}}/rejectresourceshareinvitation \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "resourceShareInvitationArn": "",\n  "clientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/rejectresourceshareinvitation

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "resourceShareInvitationArn": "",
  "clientToken": ""
] as [String : Any]

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

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

{{baseUrl}}/replacepermissionassociations

BODY json

{
  "fromPermissionArn": "",
  "fromPermissionVersion": 0,
  "toPermissionArn": "",
  "clientToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/replacepermissionassociations");

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  \"fromPermissionArn\": \"\",\n  \"fromPermissionVersion\": 0,\n  \"toPermissionArn\": \"\",\n  \"clientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/replacepermissionassociations" {:content-type :json
                                                                          :form-params {:fromPermissionArn ""
                                                                                        :fromPermissionVersion 0
                                                                                        :toPermissionArn ""
                                                                                        :clientToken ""}})

require "http/client"

url = "{{baseUrl}}/replacepermissionassociations"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"fromPermissionArn\": \"\",\n  \"fromPermissionVersion\": 0,\n  \"toPermissionArn\": \"\",\n  \"clientToken\": \"\"\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}}/replacepermissionassociations"),
    Content = new StringContent("{\n  \"fromPermissionArn\": \"\",\n  \"fromPermissionVersion\": 0,\n  \"toPermissionArn\": \"\",\n  \"clientToken\": \"\"\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}}/replacepermissionassociations");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"fromPermissionArn\": \"\",\n  \"fromPermissionVersion\": 0,\n  \"toPermissionArn\": \"\",\n  \"clientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/replacepermissionassociations"

	payload := strings.NewReader("{\n  \"fromPermissionArn\": \"\",\n  \"fromPermissionVersion\": 0,\n  \"toPermissionArn\": \"\",\n  \"clientToken\": \"\"\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/replacepermissionassociations HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 105

{
  "fromPermissionArn": "",
  "fromPermissionVersion": 0,
  "toPermissionArn": "",
  "clientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/replacepermissionassociations")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"fromPermissionArn\": \"\",\n  \"fromPermissionVersion\": 0,\n  \"toPermissionArn\": \"\",\n  \"clientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/replacepermissionassociations"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"fromPermissionArn\": \"\",\n  \"fromPermissionVersion\": 0,\n  \"toPermissionArn\": \"\",\n  \"clientToken\": \"\"\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  \"fromPermissionArn\": \"\",\n  \"fromPermissionVersion\": 0,\n  \"toPermissionArn\": \"\",\n  \"clientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/replacepermissionassociations")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/replacepermissionassociations")
  .header("content-type", "application/json")
  .body("{\n  \"fromPermissionArn\": \"\",\n  \"fromPermissionVersion\": 0,\n  \"toPermissionArn\": \"\",\n  \"clientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  fromPermissionArn: '',
  fromPermissionVersion: 0,
  toPermissionArn: '',
  clientToken: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/replacepermissionassociations',
  headers: {'content-type': 'application/json'},
  data: {
    fromPermissionArn: '',
    fromPermissionVersion: 0,
    toPermissionArn: '',
    clientToken: ''
  }
};

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

const url = '{{baseUrl}}/replacepermissionassociations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"fromPermissionArn":"","fromPermissionVersion":0,"toPermissionArn":"","clientToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/replacepermissionassociations',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "fromPermissionArn": "",\n  "fromPermissionVersion": 0,\n  "toPermissionArn": "",\n  "clientToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"fromPermissionArn\": \"\",\n  \"fromPermissionVersion\": 0,\n  \"toPermissionArn\": \"\",\n  \"clientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/replacepermissionassociations")
  .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/replacepermissionassociations',
  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({
  fromPermissionArn: '',
  fromPermissionVersion: 0,
  toPermissionArn: '',
  clientToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/replacepermissionassociations',
  headers: {'content-type': 'application/json'},
  body: {
    fromPermissionArn: '',
    fromPermissionVersion: 0,
    toPermissionArn: '',
    clientToken: ''
  },
  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}}/replacepermissionassociations');

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

req.type('json');
req.send({
  fromPermissionArn: '',
  fromPermissionVersion: 0,
  toPermissionArn: '',
  clientToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/replacepermissionassociations',
  headers: {'content-type': 'application/json'},
  data: {
    fromPermissionArn: '',
    fromPermissionVersion: 0,
    toPermissionArn: '',
    clientToken: ''
  }
};

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

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

const url = '{{baseUrl}}/replacepermissionassociations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"fromPermissionArn":"","fromPermissionVersion":0,"toPermissionArn":"","clientToken":""}'
};

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 = @{ @"fromPermissionArn": @"",
                              @"fromPermissionVersion": @0,
                              @"toPermissionArn": @"",
                              @"clientToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/replacepermissionassociations"]
                                                       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}}/replacepermissionassociations" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"fromPermissionArn\": \"\",\n  \"fromPermissionVersion\": 0,\n  \"toPermissionArn\": \"\",\n  \"clientToken\": \"\"\n}" in

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

 "{{baseUrl}}/replacepermissionassociations",
  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([
    'fromPermissionArn' => '',
    'fromPermissionVersion' => 0,
    'toPermissionArn' => '',
    'clientToken' => ''
  ]),
  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}}/replacepermissionassociations', [
  'body' => '{
  "fromPermissionArn": "",
  "fromPermissionVersion": 0,
  "toPermissionArn": "",
  "clientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/replacepermissionassociations');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'fromPermissionArn' => '',
  'fromPermissionVersion' => 0,
  'toPermissionArn' => '',
  'clientToken' => ''
]));

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

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

append(json_encode([
  'fromPermissionArn' => '',
  'fromPermissionVersion' => 0,
  'toPermissionArn' => '',
  'clientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/replacepermissionassociations');
$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}}/replacepermissionassociations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "fromPermissionArn": "",
  "fromPermissionVersion": 0,
  "toPermissionArn": "",
  "clientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/replacepermissionassociations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "fromPermissionArn": "",
  "fromPermissionVersion": 0,
  "toPermissionArn": "",
  "clientToken": ""
}'

import http.client

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

payload = "{\n  \"fromPermissionArn\": \"\",\n  \"fromPermissionVersion\": 0,\n  \"toPermissionArn\": \"\",\n  \"clientToken\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/replacepermissionassociations"

payload = {
    "fromPermissionArn": "",
    "fromPermissionVersion": 0,
    "toPermissionArn": "",
    "clientToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/replacepermissionassociations"

payload <- "{\n  \"fromPermissionArn\": \"\",\n  \"fromPermissionVersion\": 0,\n  \"toPermissionArn\": \"\",\n  \"clientToken\": \"\"\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}}/replacepermissionassociations")

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  \"fromPermissionArn\": \"\",\n  \"fromPermissionVersion\": 0,\n  \"toPermissionArn\": \"\",\n  \"clientToken\": \"\"\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/replacepermissionassociations') do |req|
  req.body = "{\n  \"fromPermissionArn\": \"\",\n  \"fromPermissionVersion\": 0,\n  \"toPermissionArn\": \"\",\n  \"clientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "fromPermissionArn": "",
        "fromPermissionVersion": 0,
        "toPermissionArn": "",
        "clientToken": ""
    });

    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}}/replacepermissionassociations \
  --header 'content-type: application/json' \
  --data '{
  "fromPermissionArn": "",
  "fromPermissionVersion": 0,
  "toPermissionArn": "",
  "clientToken": ""
}'

echo '{
  "fromPermissionArn": "",
  "fromPermissionVersion": 0,
  "toPermissionArn": "",
  "clientToken": ""
}' |  \
  http POST {{baseUrl}}/replacepermissionassociations \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "fromPermissionArn": "",\n  "fromPermissionVersion": 0,\n  "toPermissionArn": "",\n  "clientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/replacepermissionassociations

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "fromPermissionArn": "",
  "fromPermissionVersion": 0,
  "toPermissionArn": "",
  "clientToken": ""
] as [String : Any]

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

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

{{baseUrl}}/setdefaultpermissionversion

BODY json

{
  "permissionArn": "",
  "permissionVersion": 0,
  "clientToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/setdefaultpermissionversion");

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  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"clientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/setdefaultpermissionversion" {:content-type :json
                                                                        :form-params {:permissionArn ""
                                                                                      :permissionVersion 0
                                                                                      :clientToken ""}})

require "http/client"

url = "{{baseUrl}}/setdefaultpermissionversion"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"clientToken\": \"\"\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}}/setdefaultpermissionversion"),
    Content = new StringContent("{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"clientToken\": \"\"\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}}/setdefaultpermissionversion");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"clientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/setdefaultpermissionversion"

	payload := strings.NewReader("{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"clientToken\": \"\"\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/setdefaultpermissionversion HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 72

{
  "permissionArn": "",
  "permissionVersion": 0,
  "clientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/setdefaultpermissionversion")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"clientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/setdefaultpermissionversion"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"clientToken\": \"\"\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  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"clientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/setdefaultpermissionversion")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/setdefaultpermissionversion")
  .header("content-type", "application/json")
  .body("{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"clientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  permissionArn: '',
  permissionVersion: 0,
  clientToken: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/setdefaultpermissionversion',
  headers: {'content-type': 'application/json'},
  data: {permissionArn: '', permissionVersion: 0, clientToken: ''}
};

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

const url = '{{baseUrl}}/setdefaultpermissionversion';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"permissionArn":"","permissionVersion":0,"clientToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/setdefaultpermissionversion',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "permissionArn": "",\n  "permissionVersion": 0,\n  "clientToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"clientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/setdefaultpermissionversion")
  .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/setdefaultpermissionversion',
  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({permissionArn: '', permissionVersion: 0, clientToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/setdefaultpermissionversion',
  headers: {'content-type': 'application/json'},
  body: {permissionArn: '', permissionVersion: 0, clientToken: ''},
  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}}/setdefaultpermissionversion');

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

req.type('json');
req.send({
  permissionArn: '',
  permissionVersion: 0,
  clientToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/setdefaultpermissionversion',
  headers: {'content-type': 'application/json'},
  data: {permissionArn: '', permissionVersion: 0, clientToken: ''}
};

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

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

const url = '{{baseUrl}}/setdefaultpermissionversion';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"permissionArn":"","permissionVersion":0,"clientToken":""}'
};

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 = @{ @"permissionArn": @"",
                              @"permissionVersion": @0,
                              @"clientToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/setdefaultpermissionversion"]
                                                       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}}/setdefaultpermissionversion" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"clientToken\": \"\"\n}" in

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

 "{{baseUrl}}/setdefaultpermissionversion",
  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([
    'permissionArn' => '',
    'permissionVersion' => 0,
    'clientToken' => ''
  ]),
  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}}/setdefaultpermissionversion', [
  'body' => '{
  "permissionArn": "",
  "permissionVersion": 0,
  "clientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/setdefaultpermissionversion');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'permissionArn' => '',
  'permissionVersion' => 0,
  'clientToken' => ''
]));

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

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

append(json_encode([
  'permissionArn' => '',
  'permissionVersion' => 0,
  'clientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/setdefaultpermissionversion');
$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}}/setdefaultpermissionversion' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "permissionArn": "",
  "permissionVersion": 0,
  "clientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/setdefaultpermissionversion' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "permissionArn": "",
  "permissionVersion": 0,
  "clientToken": ""
}'

import http.client

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

payload = "{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"clientToken\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/setdefaultpermissionversion"

payload = {
    "permissionArn": "",
    "permissionVersion": 0,
    "clientToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/setdefaultpermissionversion"

payload <- "{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"clientToken\": \"\"\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}}/setdefaultpermissionversion")

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  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"clientToken\": \"\"\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/setdefaultpermissionversion') do |req|
  req.body = "{\n  \"permissionArn\": \"\",\n  \"permissionVersion\": 0,\n  \"clientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "permissionArn": "",
        "permissionVersion": 0,
        "clientToken": ""
    });

    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}}/setdefaultpermissionversion \
  --header 'content-type: application/json' \
  --data '{
  "permissionArn": "",
  "permissionVersion": 0,
  "clientToken": ""
}'

echo '{
  "permissionArn": "",
  "permissionVersion": 0,
  "clientToken": ""
}' |  \
  http POST {{baseUrl}}/setdefaultpermissionversion \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "permissionArn": "",\n  "permissionVersion": 0,\n  "clientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/setdefaultpermissionversion

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "permissionArn": "",
  "permissionVersion": 0,
  "clientToken": ""
] as [String : Any]

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

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

BODY json

{
  "resourceShareArn": "",
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ],
  "resourceArn": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tagresource");

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  \"resourceShareArn\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"resourceArn\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/tagresource" {:content-type :json
                                                        :form-params {:resourceShareArn ""
                                                                      :tags [{:key ""
                                                                              :value ""}]
                                                                      :resourceArn ""}})

require "http/client"

url = "{{baseUrl}}/tagresource"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"resourceShareArn\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"resourceArn\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/tagresource"),
    Content = new StringContent("{\n  \"resourceShareArn\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"resourceArn\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tagresource");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"resourceShareArn\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"resourceArn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tagresource"

	payload := strings.NewReader("{\n  \"resourceShareArn\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"resourceArn\": \"\"\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/tagresource HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 113

{
  "resourceShareArn": "",
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ],
  "resourceArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/tagresource")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"resourceShareArn\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"resourceArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tagresource"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"resourceShareArn\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"resourceArn\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"resourceShareArn\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"resourceArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/tagresource")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/tagresource")
  .header("content-type", "application/json")
  .body("{\n  \"resourceShareArn\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"resourceArn\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  resourceShareArn: '',
  tags: [
    {
      key: '',
      value: ''
    }
  ],
  resourceArn: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tagresource',
  headers: {'content-type': 'application/json'},
  data: {resourceShareArn: '', tags: [{key: '', value: ''}], resourceArn: ''}
};

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

const url = '{{baseUrl}}/tagresource';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceShareArn":"","tags":[{"key":"","value":""}],"resourceArn":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/tagresource',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "resourceShareArn": "",\n  "tags": [\n    {\n      "key": "",\n      "value": ""\n    }\n  ],\n  "resourceArn": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"resourceShareArn\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"resourceArn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/tagresource")
  .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/tagresource',
  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({resourceShareArn: '', tags: [{key: '', value: ''}], resourceArn: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tagresource',
  headers: {'content-type': 'application/json'},
  body: {resourceShareArn: '', tags: [{key: '', value: ''}], resourceArn: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/tagresource');

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

req.type('json');
req.send({
  resourceShareArn: '',
  tags: [
    {
      key: '',
      value: ''
    }
  ],
  resourceArn: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tagresource',
  headers: {'content-type': 'application/json'},
  data: {resourceShareArn: '', tags: [{key: '', value: ''}], resourceArn: ''}
};

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

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

const url = '{{baseUrl}}/tagresource';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceShareArn":"","tags":[{"key":"","value":""}],"resourceArn":""}'
};

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 = @{ @"resourceShareArn": @"",
                              @"tags": @[ @{ @"key": @"", @"value": @"" } ],
                              @"resourceArn": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tagresource"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/tagresource" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"resourceShareArn\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"resourceArn\": \"\"\n}" in

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

 "{{baseUrl}}/tagresource",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'resourceShareArn' => '',
    'tags' => [
        [
                'key' => '',
                'value' => ''
        ]
    ],
    'resourceArn' => ''
  ]),
  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}}/tagresource', [
  'body' => '{
  "resourceShareArn": "",
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ],
  "resourceArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tagresource');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'resourceShareArn' => '',
  'tags' => [
    [
        'key' => '',
        'value' => ''
    ]
  ],
  'resourceArn' => ''
]));

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

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

append(json_encode([
  'resourceShareArn' => '',
  'tags' => [
    [
        'key' => '',
        'value' => ''
    ]
  ],
  'resourceArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/tagresource');
$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}}/tagresource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceShareArn": "",
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ],
  "resourceArn": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tagresource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceShareArn": "",
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ],
  "resourceArn": ""
}'

import http.client

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

payload = "{\n  \"resourceShareArn\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"resourceArn\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/tagresource"

payload = {
    "resourceShareArn": "",
    "tags": [
        {
            "key": "",
            "value": ""
        }
    ],
    "resourceArn": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/tagresource"

payload <- "{\n  \"resourceShareArn\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"resourceArn\": \"\"\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}}/tagresource")

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  \"resourceShareArn\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"resourceArn\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/tagresource') do |req|
  req.body = "{\n  \"resourceShareArn\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"resourceArn\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "resourceShareArn": "",
        "tags": (
            json!({
                "key": "",
                "value": ""
            })
        ),
        "resourceArn": ""
    });

    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}}/tagresource \
  --header 'content-type: application/json' \
  --data '{
  "resourceShareArn": "",
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ],
  "resourceArn": ""
}'

echo '{
  "resourceShareArn": "",
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ],
  "resourceArn": ""
}' |  \
  http POST {{baseUrl}}/tagresource \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "resourceShareArn": "",\n  "tags": [\n    {\n      "key": "",\n      "value": ""\n    }\n  ],\n  "resourceArn": ""\n}' \
  --output-document \
  - {{baseUrl}}/tagresource

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "resourceShareArn": "",
  "tags": [
    [
      "key": "",
      "value": ""
    ]
  ],
  "resourceArn": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST UntagResource

{{baseUrl}}/untagresource

BODY json

{
  "resourceShareArn": "",
  "tagKeys": [],
  "resourceArn": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/untagresource");

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  \"resourceShareArn\": \"\",\n  \"tagKeys\": [],\n  \"resourceArn\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/untagresource" {:content-type :json
                                                          :form-params {:resourceShareArn ""
                                                                        :tagKeys []
                                                                        :resourceArn ""}})

require "http/client"

url = "{{baseUrl}}/untagresource"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"resourceShareArn\": \"\",\n  \"tagKeys\": [],\n  \"resourceArn\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/untagresource"),
    Content = new StringContent("{\n  \"resourceShareArn\": \"\",\n  \"tagKeys\": [],\n  \"resourceArn\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/untagresource");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"resourceShareArn\": \"\",\n  \"tagKeys\": [],\n  \"resourceArn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/untagresource"

	payload := strings.NewReader("{\n  \"resourceShareArn\": \"\",\n  \"tagKeys\": [],\n  \"resourceArn\": \"\"\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/untagresource HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 66

{
  "resourceShareArn": "",
  "tagKeys": [],
  "resourceArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/untagresource")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"resourceShareArn\": \"\",\n  \"tagKeys\": [],\n  \"resourceArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/untagresource"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"resourceShareArn\": \"\",\n  \"tagKeys\": [],\n  \"resourceArn\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"resourceShareArn\": \"\",\n  \"tagKeys\": [],\n  \"resourceArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/untagresource")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/untagresource")
  .header("content-type", "application/json")
  .body("{\n  \"resourceShareArn\": \"\",\n  \"tagKeys\": [],\n  \"resourceArn\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  resourceShareArn: '',
  tagKeys: [],
  resourceArn: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/untagresource',
  headers: {'content-type': 'application/json'},
  data: {resourceShareArn: '', tagKeys: [], resourceArn: ''}
};

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

const url = '{{baseUrl}}/untagresource';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceShareArn":"","tagKeys":[],"resourceArn":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/untagresource',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "resourceShareArn": "",\n  "tagKeys": [],\n  "resourceArn": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"resourceShareArn\": \"\",\n  \"tagKeys\": [],\n  \"resourceArn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/untagresource")
  .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/untagresource',
  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({resourceShareArn: '', tagKeys: [], resourceArn: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/untagresource',
  headers: {'content-type': 'application/json'},
  body: {resourceShareArn: '', tagKeys: [], resourceArn: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/untagresource');

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

req.type('json');
req.send({
  resourceShareArn: '',
  tagKeys: [],
  resourceArn: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/untagresource',
  headers: {'content-type': 'application/json'},
  data: {resourceShareArn: '', tagKeys: [], resourceArn: ''}
};

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

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

const url = '{{baseUrl}}/untagresource';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceShareArn":"","tagKeys":[],"resourceArn":""}'
};

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 = @{ @"resourceShareArn": @"",
                              @"tagKeys": @[  ],
                              @"resourceArn": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/untagresource"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/untagresource" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"resourceShareArn\": \"\",\n  \"tagKeys\": [],\n  \"resourceArn\": \"\"\n}" in

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

 "{{baseUrl}}/untagresource",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'resourceShareArn' => '',
    'tagKeys' => [
        
    ],
    'resourceArn' => ''
  ]),
  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}}/untagresource', [
  'body' => '{
  "resourceShareArn": "",
  "tagKeys": [],
  "resourceArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/untagresource');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'resourceShareArn' => '',
  'tagKeys' => [
    
  ],
  'resourceArn' => ''
]));

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

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

append(json_encode([
  'resourceShareArn' => '',
  'tagKeys' => [
    
  ],
  'resourceArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/untagresource');
$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}}/untagresource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceShareArn": "",
  "tagKeys": [],
  "resourceArn": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/untagresource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceShareArn": "",
  "tagKeys": [],
  "resourceArn": ""
}'

import http.client

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

payload = "{\n  \"resourceShareArn\": \"\",\n  \"tagKeys\": [],\n  \"resourceArn\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/untagresource"

payload = {
    "resourceShareArn": "",
    "tagKeys": [],
    "resourceArn": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/untagresource"

payload <- "{\n  \"resourceShareArn\": \"\",\n  \"tagKeys\": [],\n  \"resourceArn\": \"\"\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}}/untagresource")

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  \"resourceShareArn\": \"\",\n  \"tagKeys\": [],\n  \"resourceArn\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/untagresource') do |req|
  req.body = "{\n  \"resourceShareArn\": \"\",\n  \"tagKeys\": [],\n  \"resourceArn\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/untagresource";

    let payload = json!({
        "resourceShareArn": "",
        "tagKeys": (),
        "resourceArn": ""
    });

    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}}/untagresource \
  --header 'content-type: application/json' \
  --data '{
  "resourceShareArn": "",
  "tagKeys": [],
  "resourceArn": ""
}'

echo '{
  "resourceShareArn": "",
  "tagKeys": [],
  "resourceArn": ""
}' |  \
  http POST {{baseUrl}}/untagresource \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "resourceShareArn": "",\n  "tagKeys": [],\n  "resourceArn": ""\n}' \
  --output-document \
  - {{baseUrl}}/untagresource

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "resourceShareArn": "",
  "tagKeys": [],
  "resourceArn": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/untagresource")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateResourceShare

{{baseUrl}}/updateresourceshare

BODY json

{
  "resourceShareArn": "",
  "name": "",
  "allowExternalPrincipals": false,
  "clientToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/updateresourceshare");

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  \"resourceShareArn\": \"\",\n  \"name\": \"\",\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/updateresourceshare" {:content-type :json
                                                                :form-params {:resourceShareArn ""
                                                                              :name ""
                                                                              :allowExternalPrincipals false
                                                                              :clientToken ""}})

require "http/client"

url = "{{baseUrl}}/updateresourceshare"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"resourceShareArn\": \"\",\n  \"name\": \"\",\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\"\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}}/updateresourceshare"),
    Content = new StringContent("{\n  \"resourceShareArn\": \"\",\n  \"name\": \"\",\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\"\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}}/updateresourceshare");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"resourceShareArn\": \"\",\n  \"name\": \"\",\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/updateresourceshare"

	payload := strings.NewReader("{\n  \"resourceShareArn\": \"\",\n  \"name\": \"\",\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\"\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/updateresourceshare HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 99

{
  "resourceShareArn": "",
  "name": "",
  "allowExternalPrincipals": false,
  "clientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/updateresourceshare")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"resourceShareArn\": \"\",\n  \"name\": \"\",\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/updateresourceshare"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"resourceShareArn\": \"\",\n  \"name\": \"\",\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\"\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  \"resourceShareArn\": \"\",\n  \"name\": \"\",\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/updateresourceshare")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/updateresourceshare")
  .header("content-type", "application/json")
  .body("{\n  \"resourceShareArn\": \"\",\n  \"name\": \"\",\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  resourceShareArn: '',
  name: '',
  allowExternalPrincipals: false,
  clientToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/updateresourceshare');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/updateresourceshare',
  headers: {'content-type': 'application/json'},
  data: {
    resourceShareArn: '',
    name: '',
    allowExternalPrincipals: false,
    clientToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/updateresourceshare';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceShareArn":"","name":"","allowExternalPrincipals":false,"clientToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/updateresourceshare',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "resourceShareArn": "",\n  "name": "",\n  "allowExternalPrincipals": false,\n  "clientToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"resourceShareArn\": \"\",\n  \"name\": \"\",\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/updateresourceshare")
  .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/updateresourceshare',
  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({
  resourceShareArn: '',
  name: '',
  allowExternalPrincipals: false,
  clientToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/updateresourceshare',
  headers: {'content-type': 'application/json'},
  body: {
    resourceShareArn: '',
    name: '',
    allowExternalPrincipals: false,
    clientToken: ''
  },
  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}}/updateresourceshare');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  resourceShareArn: '',
  name: '',
  allowExternalPrincipals: false,
  clientToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/updateresourceshare',
  headers: {'content-type': 'application/json'},
  data: {
    resourceShareArn: '',
    name: '',
    allowExternalPrincipals: false,
    clientToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/updateresourceshare';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourceShareArn":"","name":"","allowExternalPrincipals":false,"clientToken":""}'
};

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 = @{ @"resourceShareArn": @"",
                              @"name": @"",
                              @"allowExternalPrincipals": @NO,
                              @"clientToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/updateresourceshare"]
                                                       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}}/updateresourceshare" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"resourceShareArn\": \"\",\n  \"name\": \"\",\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/updateresourceshare",
  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([
    'resourceShareArn' => '',
    'name' => '',
    'allowExternalPrincipals' => null,
    'clientToken' => ''
  ]),
  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}}/updateresourceshare', [
  'body' => '{
  "resourceShareArn": "",
  "name": "",
  "allowExternalPrincipals": false,
  "clientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/updateresourceshare');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'resourceShareArn' => '',
  'name' => '',
  'allowExternalPrincipals' => null,
  'clientToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'resourceShareArn' => '',
  'name' => '',
  'allowExternalPrincipals' => null,
  'clientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/updateresourceshare');
$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}}/updateresourceshare' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceShareArn": "",
  "name": "",
  "allowExternalPrincipals": false,
  "clientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/updateresourceshare' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceShareArn": "",
  "name": "",
  "allowExternalPrincipals": false,
  "clientToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"resourceShareArn\": \"\",\n  \"name\": \"\",\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/updateresourceshare", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/updateresourceshare"

payload = {
    "resourceShareArn": "",
    "name": "",
    "allowExternalPrincipals": False,
    "clientToken": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/updateresourceshare"

payload <- "{\n  \"resourceShareArn\": \"\",\n  \"name\": \"\",\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\"\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}}/updateresourceshare")

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  \"resourceShareArn\": \"\",\n  \"name\": \"\",\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\"\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/updateresourceshare') do |req|
  req.body = "{\n  \"resourceShareArn\": \"\",\n  \"name\": \"\",\n  \"allowExternalPrincipals\": false,\n  \"clientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/updateresourceshare";

    let payload = json!({
        "resourceShareArn": "",
        "name": "",
        "allowExternalPrincipals": false,
        "clientToken": ""
    });

    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}}/updateresourceshare \
  --header 'content-type: application/json' \
  --data '{
  "resourceShareArn": "",
  "name": "",
  "allowExternalPrincipals": false,
  "clientToken": ""
}'

echo '{
  "resourceShareArn": "",
  "name": "",
  "allowExternalPrincipals": false,
  "clientToken": ""
}' |  \
  http POST {{baseUrl}}/updateresourceshare \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "resourceShareArn": "",\n  "name": "",\n  "allowExternalPrincipals": false,\n  "clientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/updateresourceshare

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "resourceShareArn": "",
  "name": "",
  "allowExternalPrincipals": false,
  "clientToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/updateresourceshare")! 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()