GET GET_AddClientIDToOpenIDConnectProvider
{{baseUrl}}/#Action=AddClientIDToOpenIDConnectProvider
QUERY PARAMS
OpenIDConnectProviderArn
ClientID
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=AddClientIDToOpenIDConnectProvider");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=AddClientIDToOpenIDConnectProvider" {:query-params {:OpenIDConnectProviderArn ""
                                                                                                     :ClientID ""
                                                                                                     :Action ""
                                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=AddClientIDToOpenIDConnectProvider"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=AddClientIDToOpenIDConnectProvider"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=AddClientIDToOpenIDConnectProvider");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=AddClientIDToOpenIDConnectProvider"

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

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

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

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

}
GET /baseUrl/?OpenIDConnectProviderArn=&ClientID=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=AddClientIDToOpenIDConnectProvider")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=AddClientIDToOpenIDConnectProvider"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=AddClientIDToOpenIDConnectProvider")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=AddClientIDToOpenIDConnectProvider")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=AddClientIDToOpenIDConnectProvider');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=AddClientIDToOpenIDConnectProvider',
  params: {OpenIDConnectProviderArn: '', ClientID: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=AddClientIDToOpenIDConnectProvider';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=AddClientIDToOpenIDConnectProvider',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=AddClientIDToOpenIDConnectProvider")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=AddClientIDToOpenIDConnectProvider',
  qs: {OpenIDConnectProviderArn: '', ClientID: '', Action: '', Version: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=AddClientIDToOpenIDConnectProvider');

req.query({
  OpenIDConnectProviderArn: '',
  ClientID: '',
  Action: '',
  Version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=AddClientIDToOpenIDConnectProvider',
  params: {OpenIDConnectProviderArn: '', ClientID: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=AddClientIDToOpenIDConnectProvider';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=AddClientIDToOpenIDConnectProvider"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=AddClientIDToOpenIDConnectProvider" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=AddClientIDToOpenIDConnectProvider",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=AddClientIDToOpenIDConnectProvider');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=AddClientIDToOpenIDConnectProvider');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'OpenIDConnectProviderArn' => '',
  'ClientID' => '',
  'Action' => '',
  'Version' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=AddClientIDToOpenIDConnectProvider');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'OpenIDConnectProviderArn' => '',
  'ClientID' => '',
  'Action' => '',
  'Version' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=AddClientIDToOpenIDConnectProvider' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=AddClientIDToOpenIDConnectProvider' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=")

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

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

url = "{{baseUrl}}/#Action=AddClientIDToOpenIDConnectProvider"

querystring = {"OpenIDConnectProviderArn":"","ClientID":"","Action":"","Version":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=AddClientIDToOpenIDConnectProvider"

queryString <- list(
  OpenIDConnectProviderArn = "",
  ClientID = "",
  Action = "",
  Version = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=AddClientIDToOpenIDConnectProvider")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/') do |req|
  req.params['OpenIDConnectProviderArn'] = ''
  req.params['ClientID'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("OpenIDConnectProviderArn", ""),
        ("ClientID", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=AddClientIDToOpenIDConnectProvider'
http GET '{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=AddClientIDToOpenIDConnectProvider'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=AddClientIDToOpenIDConnectProvider'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=AddClientIDToOpenIDConnectProvider")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET GET_AddRoleToInstanceProfile
{{baseUrl}}/#Action=AddRoleToInstanceProfile
QUERY PARAMS
InstanceProfileName
RoleName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=AddRoleToInstanceProfile");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=AddRoleToInstanceProfile" {:query-params {:InstanceProfileName ""
                                                                                           :RoleName ""
                                                                                           :Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=AddRoleToInstanceProfile"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=AddRoleToInstanceProfile"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=AddRoleToInstanceProfile");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=AddRoleToInstanceProfile"

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

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

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

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

}
GET /baseUrl/?InstanceProfileName=&RoleName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=AddRoleToInstanceProfile")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=AddRoleToInstanceProfile"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=AddRoleToInstanceProfile")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=AddRoleToInstanceProfile")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=AddRoleToInstanceProfile');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=AddRoleToInstanceProfile',
  params: {InstanceProfileName: '', RoleName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=AddRoleToInstanceProfile';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=AddRoleToInstanceProfile',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=AddRoleToInstanceProfile")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?InstanceProfileName=&RoleName=&Action=&Version=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=AddRoleToInstanceProfile',
  qs: {InstanceProfileName: '', RoleName: '', Action: '', Version: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=AddRoleToInstanceProfile');

req.query({
  InstanceProfileName: '',
  RoleName: '',
  Action: '',
  Version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=AddRoleToInstanceProfile',
  params: {InstanceProfileName: '', RoleName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=AddRoleToInstanceProfile';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=AddRoleToInstanceProfile"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=AddRoleToInstanceProfile" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=AddRoleToInstanceProfile",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=AddRoleToInstanceProfile');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=AddRoleToInstanceProfile');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'InstanceProfileName' => '',
  'RoleName' => '',
  'Action' => '',
  'Version' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=AddRoleToInstanceProfile');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'InstanceProfileName' => '',
  'RoleName' => '',
  'Action' => '',
  'Version' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=AddRoleToInstanceProfile' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=AddRoleToInstanceProfile' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/?InstanceProfileName=&RoleName=&Action=&Version=")

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

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

url = "{{baseUrl}}/#Action=AddRoleToInstanceProfile"

querystring = {"InstanceProfileName":"","RoleName":"","Action":"","Version":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=AddRoleToInstanceProfile"

queryString <- list(
  InstanceProfileName = "",
  RoleName = "",
  Action = "",
  Version = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=AddRoleToInstanceProfile")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/') do |req|
  req.params['InstanceProfileName'] = ''
  req.params['RoleName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("InstanceProfileName", ""),
        ("RoleName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=AddRoleToInstanceProfile'
http GET '{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=AddRoleToInstanceProfile'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=AddRoleToInstanceProfile'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=AddRoleToInstanceProfile")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET GET_AddUserToGroup
{{baseUrl}}/#Action=AddUserToGroup
QUERY PARAMS
GroupName
UserName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=AddUserToGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=AddUserToGroup" {:query-params {:GroupName ""
                                                                                 :UserName ""
                                                                                 :Action ""
                                                                                 :Version ""}})
require "http/client"

url = "{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=AddUserToGroup"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=AddUserToGroup"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=AddUserToGroup");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=AddUserToGroup"

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

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

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

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

}
GET /baseUrl/?GroupName=&UserName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=AddUserToGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=AddUserToGroup"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=AddUserToGroup")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=AddUserToGroup")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=AddUserToGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=AddUserToGroup',
  params: {GroupName: '', UserName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=AddUserToGroup';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=AddUserToGroup',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=AddUserToGroup")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?GroupName=&UserName=&Action=&Version=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=AddUserToGroup',
  qs: {GroupName: '', UserName: '', Action: '', Version: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=AddUserToGroup');

req.query({
  GroupName: '',
  UserName: '',
  Action: '',
  Version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=AddUserToGroup',
  params: {GroupName: '', UserName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=AddUserToGroup';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=AddUserToGroup"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=AddUserToGroup" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=AddUserToGroup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=AddUserToGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=AddUserToGroup');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'GroupName' => '',
  'UserName' => '',
  'Action' => '',
  'Version' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=AddUserToGroup');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'GroupName' => '',
  'UserName' => '',
  'Action' => '',
  'Version' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=AddUserToGroup' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=AddUserToGroup' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/?GroupName=&UserName=&Action=&Version=")

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

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

url = "{{baseUrl}}/#Action=AddUserToGroup"

querystring = {"GroupName":"","UserName":"","Action":"","Version":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=AddUserToGroup"

queryString <- list(
  GroupName = "",
  UserName = "",
  Action = "",
  Version = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=AddUserToGroup")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/') do |req|
  req.params['GroupName'] = ''
  req.params['UserName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("GroupName", ""),
        ("UserName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=AddUserToGroup'
http GET '{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=AddUserToGroup'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=AddUserToGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=AddUserToGroup")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET GET_AttachGroupPolicy
{{baseUrl}}/#Action=AttachGroupPolicy
QUERY PARAMS
GroupName
PolicyArn
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=AttachGroupPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=AttachGroupPolicy" {:query-params {:GroupName ""
                                                                                    :PolicyArn ""
                                                                                    :Action ""
                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=AttachGroupPolicy"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=AttachGroupPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=AttachGroupPolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=AttachGroupPolicy"

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

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

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

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

}
GET /baseUrl/?GroupName=&PolicyArn=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=AttachGroupPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=AttachGroupPolicy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=AttachGroupPolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=AttachGroupPolicy")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=AttachGroupPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=AttachGroupPolicy',
  params: {GroupName: '', PolicyArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=AttachGroupPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=AttachGroupPolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=AttachGroupPolicy")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?GroupName=&PolicyArn=&Action=&Version=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=AttachGroupPolicy',
  qs: {GroupName: '', PolicyArn: '', Action: '', Version: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=AttachGroupPolicy');

req.query({
  GroupName: '',
  PolicyArn: '',
  Action: '',
  Version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=AttachGroupPolicy',
  params: {GroupName: '', PolicyArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=AttachGroupPolicy';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=AttachGroupPolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=AttachGroupPolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=AttachGroupPolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=AttachGroupPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=AttachGroupPolicy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'GroupName' => '',
  'PolicyArn' => '',
  'Action' => '',
  'Version' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=AttachGroupPolicy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'GroupName' => '',
  'PolicyArn' => '',
  'Action' => '',
  'Version' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=AttachGroupPolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=AttachGroupPolicy' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/?GroupName=&PolicyArn=&Action=&Version=")

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

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

url = "{{baseUrl}}/#Action=AttachGroupPolicy"

querystring = {"GroupName":"","PolicyArn":"","Action":"","Version":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=AttachGroupPolicy"

queryString <- list(
  GroupName = "",
  PolicyArn = "",
  Action = "",
  Version = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=AttachGroupPolicy")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/') do |req|
  req.params['GroupName'] = ''
  req.params['PolicyArn'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("GroupName", ""),
        ("PolicyArn", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=AttachGroupPolicy'
http GET '{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=AttachGroupPolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=AttachGroupPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=AttachGroupPolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET GET_AttachRolePolicy
{{baseUrl}}/#Action=AttachRolePolicy
QUERY PARAMS
RoleName
PolicyArn
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=AttachRolePolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=AttachRolePolicy" {:query-params {:RoleName ""
                                                                                   :PolicyArn ""
                                                                                   :Action ""
                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=AttachRolePolicy"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=AttachRolePolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=AttachRolePolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=AttachRolePolicy"

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

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

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

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

}
GET /baseUrl/?RoleName=&PolicyArn=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=AttachRolePolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=AttachRolePolicy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=AttachRolePolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=AttachRolePolicy")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=AttachRolePolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=AttachRolePolicy',
  params: {RoleName: '', PolicyArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=AttachRolePolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=AttachRolePolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=AttachRolePolicy")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?RoleName=&PolicyArn=&Action=&Version=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=AttachRolePolicy',
  qs: {RoleName: '', PolicyArn: '', Action: '', Version: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=AttachRolePolicy');

req.query({
  RoleName: '',
  PolicyArn: '',
  Action: '',
  Version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=AttachRolePolicy',
  params: {RoleName: '', PolicyArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=AttachRolePolicy';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=AttachRolePolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=AttachRolePolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=AttachRolePolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=AttachRolePolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=AttachRolePolicy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'RoleName' => '',
  'PolicyArn' => '',
  'Action' => '',
  'Version' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=AttachRolePolicy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'RoleName' => '',
  'PolicyArn' => '',
  'Action' => '',
  'Version' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=AttachRolePolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=AttachRolePolicy' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/?RoleName=&PolicyArn=&Action=&Version=")

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

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

url = "{{baseUrl}}/#Action=AttachRolePolicy"

querystring = {"RoleName":"","PolicyArn":"","Action":"","Version":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=AttachRolePolicy"

queryString <- list(
  RoleName = "",
  PolicyArn = "",
  Action = "",
  Version = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=AttachRolePolicy")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/') do |req|
  req.params['RoleName'] = ''
  req.params['PolicyArn'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("RoleName", ""),
        ("PolicyArn", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=AttachRolePolicy'
http GET '{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=AttachRolePolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=AttachRolePolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=AttachRolePolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET GET_AttachUserPolicy
{{baseUrl}}/#Action=AttachUserPolicy
QUERY PARAMS
UserName
PolicyArn
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=AttachUserPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=AttachUserPolicy" {:query-params {:UserName ""
                                                                                   :PolicyArn ""
                                                                                   :Action ""
                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=AttachUserPolicy"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=AttachUserPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=AttachUserPolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=AttachUserPolicy"

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

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

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

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

}
GET /baseUrl/?UserName=&PolicyArn=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=AttachUserPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=AttachUserPolicy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=AttachUserPolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=AttachUserPolicy")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=AttachUserPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=AttachUserPolicy',
  params: {UserName: '', PolicyArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=AttachUserPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=AttachUserPolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=AttachUserPolicy")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?UserName=&PolicyArn=&Action=&Version=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=AttachUserPolicy',
  qs: {UserName: '', PolicyArn: '', Action: '', Version: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=AttachUserPolicy');

req.query({
  UserName: '',
  PolicyArn: '',
  Action: '',
  Version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=AttachUserPolicy',
  params: {UserName: '', PolicyArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=AttachUserPolicy';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=AttachUserPolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=AttachUserPolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=AttachUserPolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=AttachUserPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=AttachUserPolicy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'UserName' => '',
  'PolicyArn' => '',
  'Action' => '',
  'Version' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=AttachUserPolicy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'UserName' => '',
  'PolicyArn' => '',
  'Action' => '',
  'Version' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=AttachUserPolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=AttachUserPolicy' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/?UserName=&PolicyArn=&Action=&Version=")

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

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

url = "{{baseUrl}}/#Action=AttachUserPolicy"

querystring = {"UserName":"","PolicyArn":"","Action":"","Version":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=AttachUserPolicy"

queryString <- list(
  UserName = "",
  PolicyArn = "",
  Action = "",
  Version = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=AttachUserPolicy")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/') do |req|
  req.params['UserName'] = ''
  req.params['PolicyArn'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("UserName", ""),
        ("PolicyArn", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=AttachUserPolicy'
http GET '{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=AttachUserPolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=AttachUserPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=AttachUserPolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET GET_ChangePassword
{{baseUrl}}/#Action=ChangePassword
QUERY PARAMS
OldPassword
NewPassword
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?OldPassword=&NewPassword=&Action=&Version=#Action=ChangePassword");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ChangePassword" {:query-params {:OldPassword ""
                                                                                 :NewPassword ""
                                                                                 :Action ""
                                                                                 :Version ""}})
require "http/client"

url = "{{baseUrl}}/?OldPassword=&NewPassword=&Action=&Version=#Action=ChangePassword"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?OldPassword=&NewPassword=&Action=&Version=#Action=ChangePassword"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?OldPassword=&NewPassword=&Action=&Version=#Action=ChangePassword");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?OldPassword=&NewPassword=&Action=&Version=#Action=ChangePassword"

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

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

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

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

}
GET /baseUrl/?OldPassword=&NewPassword=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?OldPassword=&NewPassword=&Action=&Version=#Action=ChangePassword")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?OldPassword=&NewPassword=&Action=&Version=#Action=ChangePassword"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?OldPassword=&NewPassword=&Action=&Version=#Action=ChangePassword")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?OldPassword=&NewPassword=&Action=&Version=#Action=ChangePassword")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/?OldPassword=&NewPassword=&Action=&Version=#Action=ChangePassword');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ChangePassword',
  params: {OldPassword: '', NewPassword: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?OldPassword=&NewPassword=&Action=&Version=#Action=ChangePassword';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?OldPassword=&NewPassword=&Action=&Version=#Action=ChangePassword',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?OldPassword=&NewPassword=&Action=&Version=#Action=ChangePassword")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?OldPassword=&NewPassword=&Action=&Version=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ChangePassword',
  qs: {OldPassword: '', NewPassword: '', Action: '', Version: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ChangePassword');

req.query({
  OldPassword: '',
  NewPassword: '',
  Action: '',
  Version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ChangePassword',
  params: {OldPassword: '', NewPassword: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?OldPassword=&NewPassword=&Action=&Version=#Action=ChangePassword';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?OldPassword=&NewPassword=&Action=&Version=#Action=ChangePassword"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/?OldPassword=&NewPassword=&Action=&Version=#Action=ChangePassword" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?OldPassword=&NewPassword=&Action=&Version=#Action=ChangePassword",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?OldPassword=&NewPassword=&Action=&Version=#Action=ChangePassword');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ChangePassword');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'OldPassword' => '',
  'NewPassword' => '',
  'Action' => '',
  'Version' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ChangePassword');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'OldPassword' => '',
  'NewPassword' => '',
  'Action' => '',
  'Version' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?OldPassword=&NewPassword=&Action=&Version=#Action=ChangePassword' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?OldPassword=&NewPassword=&Action=&Version=#Action=ChangePassword' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/?OldPassword=&NewPassword=&Action=&Version=")

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

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

url = "{{baseUrl}}/#Action=ChangePassword"

querystring = {"OldPassword":"","NewPassword":"","Action":"","Version":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ChangePassword"

queryString <- list(
  OldPassword = "",
  NewPassword = "",
  Action = "",
  Version = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?OldPassword=&NewPassword=&Action=&Version=#Action=ChangePassword")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/') do |req|
  req.params['OldPassword'] = ''
  req.params['NewPassword'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("OldPassword", ""),
        ("NewPassword", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?OldPassword=&NewPassword=&Action=&Version=#Action=ChangePassword'
http GET '{{baseUrl}}/?OldPassword=&NewPassword=&Action=&Version=#Action=ChangePassword'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?OldPassword=&NewPassword=&Action=&Version=#Action=ChangePassword'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?OldPassword=&NewPassword=&Action=&Version=#Action=ChangePassword")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET GET_CreateAccessKey
{{baseUrl}}/#Action=CreateAccessKey
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=CreateAccessKey" {:query-params {:Action ""
                                                                                  :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey"

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

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

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

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

}
GET /baseUrl/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateAccessKey',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateAccessKey',
  qs: {Action: '', Version: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=CreateAccessKey');

req.query({
  Action: '',
  Version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateAccessKey',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateAccessKey');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateAccessKey');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/?Action=&Version=")

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

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

url = "{{baseUrl}}/#Action=CreateAccessKey"

querystring = {"Action":"","Version":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateAccessKey"

queryString <- list(
  Action = "",
  Version = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey'
http GET '{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "AccessKey": {
    "AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
    "CreateDate": "2015-03-09T18:39:23.411Z",
    "SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYzEXAMPLEKEY",
    "Status": "Active",
    "UserName": "Bob"
  }
}
GET GET_CreateAccountAlias
{{baseUrl}}/#Action=CreateAccountAlias
QUERY PARAMS
AccountAlias
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=CreateAccountAlias");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=CreateAccountAlias" {:query-params {:AccountAlias ""
                                                                                     :Action ""
                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=CreateAccountAlias"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=CreateAccountAlias"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=CreateAccountAlias");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=CreateAccountAlias"

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

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

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

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

}
GET /baseUrl/?AccountAlias=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=CreateAccountAlias")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=CreateAccountAlias"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=CreateAccountAlias")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=CreateAccountAlias")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=CreateAccountAlias');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateAccountAlias',
  params: {AccountAlias: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=CreateAccountAlias';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=CreateAccountAlias',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=CreateAccountAlias")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?AccountAlias=&Action=&Version=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateAccountAlias',
  qs: {AccountAlias: '', Action: '', Version: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=CreateAccountAlias');

req.query({
  AccountAlias: '',
  Action: '',
  Version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateAccountAlias',
  params: {AccountAlias: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=CreateAccountAlias';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=CreateAccountAlias"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=CreateAccountAlias" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=CreateAccountAlias",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=CreateAccountAlias');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateAccountAlias');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'AccountAlias' => '',
  'Action' => '',
  'Version' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateAccountAlias');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'AccountAlias' => '',
  'Action' => '',
  'Version' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=CreateAccountAlias' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=CreateAccountAlias' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/?AccountAlias=&Action=&Version=")

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

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

url = "{{baseUrl}}/#Action=CreateAccountAlias"

querystring = {"AccountAlias":"","Action":"","Version":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateAccountAlias"

queryString <- list(
  AccountAlias = "",
  Action = "",
  Version = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=CreateAccountAlias")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/') do |req|
  req.params['AccountAlias'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("AccountAlias", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=CreateAccountAlias'
http GET '{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=CreateAccountAlias'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=CreateAccountAlias'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=CreateAccountAlias")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET GET_CreateGroup
{{baseUrl}}/#Action=CreateGroup
QUERY PARAMS
GroupName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?GroupName=&Action=&Version=#Action=CreateGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=CreateGroup" {:query-params {:GroupName ""
                                                                              :Action ""
                                                                              :Version ""}})
require "http/client"

url = "{{baseUrl}}/?GroupName=&Action=&Version=#Action=CreateGroup"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?GroupName=&Action=&Version=#Action=CreateGroup"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?GroupName=&Action=&Version=#Action=CreateGroup");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?GroupName=&Action=&Version=#Action=CreateGroup"

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

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

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

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

}
GET /baseUrl/?GroupName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?GroupName=&Action=&Version=#Action=CreateGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?GroupName=&Action=&Version=#Action=CreateGroup"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?GroupName=&Action=&Version=#Action=CreateGroup")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?GroupName=&Action=&Version=#Action=CreateGroup")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/?GroupName=&Action=&Version=#Action=CreateGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateGroup',
  params: {GroupName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?GroupName=&Action=&Version=#Action=CreateGroup';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?GroupName=&Action=&Version=#Action=CreateGroup',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?GroupName=&Action=&Version=#Action=CreateGroup")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?GroupName=&Action=&Version=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateGroup',
  qs: {GroupName: '', Action: '', Version: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=CreateGroup');

req.query({
  GroupName: '',
  Action: '',
  Version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateGroup',
  params: {GroupName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?GroupName=&Action=&Version=#Action=CreateGroup';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?GroupName=&Action=&Version=#Action=CreateGroup"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/?GroupName=&Action=&Version=#Action=CreateGroup" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?GroupName=&Action=&Version=#Action=CreateGroup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?GroupName=&Action=&Version=#Action=CreateGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateGroup');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'GroupName' => '',
  'Action' => '',
  'Version' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateGroup');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'GroupName' => '',
  'Action' => '',
  'Version' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?GroupName=&Action=&Version=#Action=CreateGroup' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?GroupName=&Action=&Version=#Action=CreateGroup' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/?GroupName=&Action=&Version=")

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

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

url = "{{baseUrl}}/#Action=CreateGroup"

querystring = {"GroupName":"","Action":"","Version":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateGroup"

queryString <- list(
  GroupName = "",
  Action = "",
  Version = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?GroupName=&Action=&Version=#Action=CreateGroup")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/') do |req|
  req.params['GroupName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("GroupName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?GroupName=&Action=&Version=#Action=CreateGroup'
http GET '{{baseUrl}}/?GroupName=&Action=&Version=#Action=CreateGroup'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?GroupName=&Action=&Version=#Action=CreateGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?GroupName=&Action=&Version=#Action=CreateGroup")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "Group": {
    "Arn": "arn:aws:iam::123456789012:group/Admins",
    "CreateDate": "2015-03-09T20:30:24.940Z",
    "GroupId": "AIDGPMS9RO4H3FEXAMPLE",
    "GroupName": "Admins",
    "Path": "/"
  }
}
GET GET_CreateInstanceProfile
{{baseUrl}}/#Action=CreateInstanceProfile
QUERY PARAMS
InstanceProfileName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=CreateInstanceProfile");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=CreateInstanceProfile" {:query-params {:InstanceProfileName ""
                                                                                        :Action ""
                                                                                        :Version ""}})
require "http/client"

url = "{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=CreateInstanceProfile"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=CreateInstanceProfile"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=CreateInstanceProfile");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=CreateInstanceProfile"

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

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

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

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

}
GET /baseUrl/?InstanceProfileName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=CreateInstanceProfile")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=CreateInstanceProfile"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=CreateInstanceProfile")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=CreateInstanceProfile")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=CreateInstanceProfile');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateInstanceProfile',
  params: {InstanceProfileName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=CreateInstanceProfile';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=CreateInstanceProfile',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=CreateInstanceProfile")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?InstanceProfileName=&Action=&Version=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateInstanceProfile',
  qs: {InstanceProfileName: '', Action: '', Version: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=CreateInstanceProfile');

req.query({
  InstanceProfileName: '',
  Action: '',
  Version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateInstanceProfile',
  params: {InstanceProfileName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=CreateInstanceProfile';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=CreateInstanceProfile"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=CreateInstanceProfile" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=CreateInstanceProfile",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=CreateInstanceProfile');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateInstanceProfile');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'InstanceProfileName' => '',
  'Action' => '',
  'Version' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateInstanceProfile');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'InstanceProfileName' => '',
  'Action' => '',
  'Version' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=CreateInstanceProfile' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=CreateInstanceProfile' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/?InstanceProfileName=&Action=&Version=")

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

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

url = "{{baseUrl}}/#Action=CreateInstanceProfile"

querystring = {"InstanceProfileName":"","Action":"","Version":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateInstanceProfile"

queryString <- list(
  InstanceProfileName = "",
  Action = "",
  Version = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=CreateInstanceProfile")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/') do |req|
  req.params['InstanceProfileName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("InstanceProfileName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=CreateInstanceProfile'
http GET '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=CreateInstanceProfile'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=CreateInstanceProfile'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=CreateInstanceProfile")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "InstanceProfile": {
    "Arn": "arn:aws:iam::123456789012:instance-profile/Webserver",
    "CreateDate": "2015-03-09T20:33:19.626Z",
    "InstanceProfileId": "AIPAJMBYC7DLSPEXAMPLE",
    "InstanceProfileName": "Webserver",
    "Path": "/",
    "Roles": []
  }
}
GET GET_CreateLoginProfile
{{baseUrl}}/#Action=CreateLoginProfile
QUERY PARAMS
UserName
Password
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?UserName=&Password=&Action=&Version=#Action=CreateLoginProfile");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=CreateLoginProfile" {:query-params {:UserName ""
                                                                                     :Password ""
                                                                                     :Action ""
                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?UserName=&Password=&Action=&Version=#Action=CreateLoginProfile"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?UserName=&Password=&Action=&Version=#Action=CreateLoginProfile"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?UserName=&Password=&Action=&Version=#Action=CreateLoginProfile");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?UserName=&Password=&Action=&Version=#Action=CreateLoginProfile"

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

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

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

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

}
GET /baseUrl/?UserName=&Password=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?UserName=&Password=&Action=&Version=#Action=CreateLoginProfile")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?UserName=&Password=&Action=&Version=#Action=CreateLoginProfile"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?UserName=&Password=&Action=&Version=#Action=CreateLoginProfile")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?UserName=&Password=&Action=&Version=#Action=CreateLoginProfile")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/?UserName=&Password=&Action=&Version=#Action=CreateLoginProfile');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateLoginProfile',
  params: {UserName: '', Password: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?UserName=&Password=&Action=&Version=#Action=CreateLoginProfile';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?UserName=&Password=&Action=&Version=#Action=CreateLoginProfile',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?UserName=&Password=&Action=&Version=#Action=CreateLoginProfile")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?UserName=&Password=&Action=&Version=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateLoginProfile',
  qs: {UserName: '', Password: '', Action: '', Version: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=CreateLoginProfile');

req.query({
  UserName: '',
  Password: '',
  Action: '',
  Version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateLoginProfile',
  params: {UserName: '', Password: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?UserName=&Password=&Action=&Version=#Action=CreateLoginProfile';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?UserName=&Password=&Action=&Version=#Action=CreateLoginProfile"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/?UserName=&Password=&Action=&Version=#Action=CreateLoginProfile" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?UserName=&Password=&Action=&Version=#Action=CreateLoginProfile",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?UserName=&Password=&Action=&Version=#Action=CreateLoginProfile');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateLoginProfile');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'UserName' => '',
  'Password' => '',
  'Action' => '',
  'Version' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateLoginProfile');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'UserName' => '',
  'Password' => '',
  'Action' => '',
  'Version' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?UserName=&Password=&Action=&Version=#Action=CreateLoginProfile' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?UserName=&Password=&Action=&Version=#Action=CreateLoginProfile' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/?UserName=&Password=&Action=&Version=")

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

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

url = "{{baseUrl}}/#Action=CreateLoginProfile"

querystring = {"UserName":"","Password":"","Action":"","Version":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateLoginProfile"

queryString <- list(
  UserName = "",
  Password = "",
  Action = "",
  Version = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?UserName=&Password=&Action=&Version=#Action=CreateLoginProfile")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/') do |req|
  req.params['UserName'] = ''
  req.params['Password'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("UserName", ""),
        ("Password", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?UserName=&Password=&Action=&Version=#Action=CreateLoginProfile'
http GET '{{baseUrl}}/?UserName=&Password=&Action=&Version=#Action=CreateLoginProfile'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?UserName=&Password=&Action=&Version=#Action=CreateLoginProfile'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?UserName=&Password=&Action=&Version=#Action=CreateLoginProfile")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "LoginProfile": {
    "CreateDate": "2015-03-10T20:55:40.274Z",
    "PasswordResetRequired": true,
    "UserName": "Bob"
  }
}
GET GET_CreateOpenIDConnectProvider
{{baseUrl}}/#Action=CreateOpenIDConnectProvider
QUERY PARAMS
Url
ThumbprintList
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Url=&ThumbprintList=&Action=&Version=#Action=CreateOpenIDConnectProvider");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=CreateOpenIDConnectProvider" {:query-params {:Url ""
                                                                                              :ThumbprintList ""
                                                                                              :Action ""
                                                                                              :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Url=&ThumbprintList=&Action=&Version=#Action=CreateOpenIDConnectProvider"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?Url=&ThumbprintList=&Action=&Version=#Action=CreateOpenIDConnectProvider"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Url=&ThumbprintList=&Action=&Version=#Action=CreateOpenIDConnectProvider");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?Url=&ThumbprintList=&Action=&Version=#Action=CreateOpenIDConnectProvider"

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

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

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

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

}
GET /baseUrl/?Url=&ThumbprintList=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?Url=&ThumbprintList=&Action=&Version=#Action=CreateOpenIDConnectProvider")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Url=&ThumbprintList=&Action=&Version=#Action=CreateOpenIDConnectProvider"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?Url=&ThumbprintList=&Action=&Version=#Action=CreateOpenIDConnectProvider")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Url=&ThumbprintList=&Action=&Version=#Action=CreateOpenIDConnectProvider")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/?Url=&ThumbprintList=&Action=&Version=#Action=CreateOpenIDConnectProvider');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateOpenIDConnectProvider',
  params: {Url: '', ThumbprintList: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Url=&ThumbprintList=&Action=&Version=#Action=CreateOpenIDConnectProvider';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?Url=&ThumbprintList=&Action=&Version=#Action=CreateOpenIDConnectProvider',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Url=&ThumbprintList=&Action=&Version=#Action=CreateOpenIDConnectProvider")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Url=&ThumbprintList=&Action=&Version=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateOpenIDConnectProvider',
  qs: {Url: '', ThumbprintList: '', Action: '', Version: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=CreateOpenIDConnectProvider');

req.query({
  Url: '',
  ThumbprintList: '',
  Action: '',
  Version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateOpenIDConnectProvider',
  params: {Url: '', ThumbprintList: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Url=&ThumbprintList=&Action=&Version=#Action=CreateOpenIDConnectProvider';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?Url=&ThumbprintList=&Action=&Version=#Action=CreateOpenIDConnectProvider"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/?Url=&ThumbprintList=&Action=&Version=#Action=CreateOpenIDConnectProvider" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Url=&ThumbprintList=&Action=&Version=#Action=CreateOpenIDConnectProvider",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?Url=&ThumbprintList=&Action=&Version=#Action=CreateOpenIDConnectProvider');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateOpenIDConnectProvider');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Url' => '',
  'ThumbprintList' => '',
  'Action' => '',
  'Version' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateOpenIDConnectProvider');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Url' => '',
  'ThumbprintList' => '',
  'Action' => '',
  'Version' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Url=&ThumbprintList=&Action=&Version=#Action=CreateOpenIDConnectProvider' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Url=&ThumbprintList=&Action=&Version=#Action=CreateOpenIDConnectProvider' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/?Url=&ThumbprintList=&Action=&Version=")

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

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

url = "{{baseUrl}}/#Action=CreateOpenIDConnectProvider"

querystring = {"Url":"","ThumbprintList":"","Action":"","Version":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateOpenIDConnectProvider"

queryString <- list(
  Url = "",
  ThumbprintList = "",
  Action = "",
  Version = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Url=&ThumbprintList=&Action=&Version=#Action=CreateOpenIDConnectProvider")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/') do |req|
  req.params['Url'] = ''
  req.params['ThumbprintList'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("Url", ""),
        ("ThumbprintList", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?Url=&ThumbprintList=&Action=&Version=#Action=CreateOpenIDConnectProvider'
http GET '{{baseUrl}}/?Url=&ThumbprintList=&Action=&Version=#Action=CreateOpenIDConnectProvider'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Url=&ThumbprintList=&Action=&Version=#Action=CreateOpenIDConnectProvider'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Url=&ThumbprintList=&Action=&Version=#Action=CreateOpenIDConnectProvider")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "OpenIDConnectProviderArn": "arn:aws:iam::123456789012:oidc-provider/server.example.com"
}
GET GET_CreatePolicy
{{baseUrl}}/#Action=CreatePolicy
QUERY PARAMS
PolicyName
PolicyDocument
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?PolicyName=&PolicyDocument=&Action=&Version=#Action=CreatePolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=CreatePolicy" {:query-params {:PolicyName ""
                                                                               :PolicyDocument ""
                                                                               :Action ""
                                                                               :Version ""}})
require "http/client"

url = "{{baseUrl}}/?PolicyName=&PolicyDocument=&Action=&Version=#Action=CreatePolicy"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?PolicyName=&PolicyDocument=&Action=&Version=#Action=CreatePolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?PolicyName=&PolicyDocument=&Action=&Version=#Action=CreatePolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?PolicyName=&PolicyDocument=&Action=&Version=#Action=CreatePolicy"

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

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

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

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

}
GET /baseUrl/?PolicyName=&PolicyDocument=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?PolicyName=&PolicyDocument=&Action=&Version=#Action=CreatePolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?PolicyName=&PolicyDocument=&Action=&Version=#Action=CreatePolicy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?PolicyName=&PolicyDocument=&Action=&Version=#Action=CreatePolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?PolicyName=&PolicyDocument=&Action=&Version=#Action=CreatePolicy")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/?PolicyName=&PolicyDocument=&Action=&Version=#Action=CreatePolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreatePolicy',
  params: {PolicyName: '', PolicyDocument: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?PolicyName=&PolicyDocument=&Action=&Version=#Action=CreatePolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?PolicyName=&PolicyDocument=&Action=&Version=#Action=CreatePolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?PolicyName=&PolicyDocument=&Action=&Version=#Action=CreatePolicy")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?PolicyName=&PolicyDocument=&Action=&Version=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreatePolicy',
  qs: {PolicyName: '', PolicyDocument: '', Action: '', Version: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=CreatePolicy');

req.query({
  PolicyName: '',
  PolicyDocument: '',
  Action: '',
  Version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreatePolicy',
  params: {PolicyName: '', PolicyDocument: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?PolicyName=&PolicyDocument=&Action=&Version=#Action=CreatePolicy';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?PolicyName=&PolicyDocument=&Action=&Version=#Action=CreatePolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/?PolicyName=&PolicyDocument=&Action=&Version=#Action=CreatePolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?PolicyName=&PolicyDocument=&Action=&Version=#Action=CreatePolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?PolicyName=&PolicyDocument=&Action=&Version=#Action=CreatePolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreatePolicy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'PolicyName' => '',
  'PolicyDocument' => '',
  'Action' => '',
  'Version' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreatePolicy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'PolicyName' => '',
  'PolicyDocument' => '',
  'Action' => '',
  'Version' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?PolicyName=&PolicyDocument=&Action=&Version=#Action=CreatePolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?PolicyName=&PolicyDocument=&Action=&Version=#Action=CreatePolicy' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/?PolicyName=&PolicyDocument=&Action=&Version=")

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

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

url = "{{baseUrl}}/#Action=CreatePolicy"

querystring = {"PolicyName":"","PolicyDocument":"","Action":"","Version":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreatePolicy"

queryString <- list(
  PolicyName = "",
  PolicyDocument = "",
  Action = "",
  Version = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?PolicyName=&PolicyDocument=&Action=&Version=#Action=CreatePolicy")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/') do |req|
  req.params['PolicyName'] = ''
  req.params['PolicyDocument'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("PolicyName", ""),
        ("PolicyDocument", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?PolicyName=&PolicyDocument=&Action=&Version=#Action=CreatePolicy'
http GET '{{baseUrl}}/?PolicyName=&PolicyDocument=&Action=&Version=#Action=CreatePolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?PolicyName=&PolicyDocument=&Action=&Version=#Action=CreatePolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?PolicyName=&PolicyDocument=&Action=&Version=#Action=CreatePolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET GET_CreatePolicyVersion
{{baseUrl}}/#Action=CreatePolicyVersion
QUERY PARAMS
PolicyArn
PolicyDocument
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?PolicyArn=&PolicyDocument=&Action=&Version=#Action=CreatePolicyVersion");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=CreatePolicyVersion" {:query-params {:PolicyArn ""
                                                                                      :PolicyDocument ""
                                                                                      :Action ""
                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?PolicyArn=&PolicyDocument=&Action=&Version=#Action=CreatePolicyVersion"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?PolicyArn=&PolicyDocument=&Action=&Version=#Action=CreatePolicyVersion"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?PolicyArn=&PolicyDocument=&Action=&Version=#Action=CreatePolicyVersion");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?PolicyArn=&PolicyDocument=&Action=&Version=#Action=CreatePolicyVersion"

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

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

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

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

}
GET /baseUrl/?PolicyArn=&PolicyDocument=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?PolicyArn=&PolicyDocument=&Action=&Version=#Action=CreatePolicyVersion")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?PolicyArn=&PolicyDocument=&Action=&Version=#Action=CreatePolicyVersion"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?PolicyArn=&PolicyDocument=&Action=&Version=#Action=CreatePolicyVersion")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?PolicyArn=&PolicyDocument=&Action=&Version=#Action=CreatePolicyVersion")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/?PolicyArn=&PolicyDocument=&Action=&Version=#Action=CreatePolicyVersion');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreatePolicyVersion',
  params: {PolicyArn: '', PolicyDocument: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?PolicyArn=&PolicyDocument=&Action=&Version=#Action=CreatePolicyVersion';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?PolicyArn=&PolicyDocument=&Action=&Version=#Action=CreatePolicyVersion',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?PolicyArn=&PolicyDocument=&Action=&Version=#Action=CreatePolicyVersion")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?PolicyArn=&PolicyDocument=&Action=&Version=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreatePolicyVersion',
  qs: {PolicyArn: '', PolicyDocument: '', Action: '', Version: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=CreatePolicyVersion');

req.query({
  PolicyArn: '',
  PolicyDocument: '',
  Action: '',
  Version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreatePolicyVersion',
  params: {PolicyArn: '', PolicyDocument: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?PolicyArn=&PolicyDocument=&Action=&Version=#Action=CreatePolicyVersion';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?PolicyArn=&PolicyDocument=&Action=&Version=#Action=CreatePolicyVersion"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/?PolicyArn=&PolicyDocument=&Action=&Version=#Action=CreatePolicyVersion" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?PolicyArn=&PolicyDocument=&Action=&Version=#Action=CreatePolicyVersion",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?PolicyArn=&PolicyDocument=&Action=&Version=#Action=CreatePolicyVersion');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreatePolicyVersion');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'PolicyArn' => '',
  'PolicyDocument' => '',
  'Action' => '',
  'Version' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreatePolicyVersion');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'PolicyArn' => '',
  'PolicyDocument' => '',
  'Action' => '',
  'Version' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?PolicyArn=&PolicyDocument=&Action=&Version=#Action=CreatePolicyVersion' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?PolicyArn=&PolicyDocument=&Action=&Version=#Action=CreatePolicyVersion' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/?PolicyArn=&PolicyDocument=&Action=&Version=")

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

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

url = "{{baseUrl}}/#Action=CreatePolicyVersion"

querystring = {"PolicyArn":"","PolicyDocument":"","Action":"","Version":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreatePolicyVersion"

queryString <- list(
  PolicyArn = "",
  PolicyDocument = "",
  Action = "",
  Version = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?PolicyArn=&PolicyDocument=&Action=&Version=#Action=CreatePolicyVersion")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/') do |req|
  req.params['PolicyArn'] = ''
  req.params['PolicyDocument'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("PolicyArn", ""),
        ("PolicyDocument", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?PolicyArn=&PolicyDocument=&Action=&Version=#Action=CreatePolicyVersion'
http GET '{{baseUrl}}/?PolicyArn=&PolicyDocument=&Action=&Version=#Action=CreatePolicyVersion'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?PolicyArn=&PolicyDocument=&Action=&Version=#Action=CreatePolicyVersion'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?PolicyArn=&PolicyDocument=&Action=&Version=#Action=CreatePolicyVersion")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET GET_CreateRole
{{baseUrl}}/#Action=CreateRole
QUERY PARAMS
RoleName
AssumeRolePolicyDocument
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?RoleName=&AssumeRolePolicyDocument=&Action=&Version=#Action=CreateRole");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=CreateRole" {:query-params {:RoleName ""
                                                                             :AssumeRolePolicyDocument ""
                                                                             :Action ""
                                                                             :Version ""}})
require "http/client"

url = "{{baseUrl}}/?RoleName=&AssumeRolePolicyDocument=&Action=&Version=#Action=CreateRole"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?RoleName=&AssumeRolePolicyDocument=&Action=&Version=#Action=CreateRole"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?RoleName=&AssumeRolePolicyDocument=&Action=&Version=#Action=CreateRole");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?RoleName=&AssumeRolePolicyDocument=&Action=&Version=#Action=CreateRole"

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

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

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

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

}
GET /baseUrl/?RoleName=&AssumeRolePolicyDocument=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?RoleName=&AssumeRolePolicyDocument=&Action=&Version=#Action=CreateRole")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?RoleName=&AssumeRolePolicyDocument=&Action=&Version=#Action=CreateRole"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?RoleName=&AssumeRolePolicyDocument=&Action=&Version=#Action=CreateRole")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?RoleName=&AssumeRolePolicyDocument=&Action=&Version=#Action=CreateRole")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/?RoleName=&AssumeRolePolicyDocument=&Action=&Version=#Action=CreateRole');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateRole',
  params: {RoleName: '', AssumeRolePolicyDocument: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?RoleName=&AssumeRolePolicyDocument=&Action=&Version=#Action=CreateRole';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?RoleName=&AssumeRolePolicyDocument=&Action=&Version=#Action=CreateRole',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?RoleName=&AssumeRolePolicyDocument=&Action=&Version=#Action=CreateRole")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?RoleName=&AssumeRolePolicyDocument=&Action=&Version=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateRole',
  qs: {RoleName: '', AssumeRolePolicyDocument: '', Action: '', Version: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=CreateRole');

req.query({
  RoleName: '',
  AssumeRolePolicyDocument: '',
  Action: '',
  Version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateRole',
  params: {RoleName: '', AssumeRolePolicyDocument: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?RoleName=&AssumeRolePolicyDocument=&Action=&Version=#Action=CreateRole';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?RoleName=&AssumeRolePolicyDocument=&Action=&Version=#Action=CreateRole"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/?RoleName=&AssumeRolePolicyDocument=&Action=&Version=#Action=CreateRole" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?RoleName=&AssumeRolePolicyDocument=&Action=&Version=#Action=CreateRole",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?RoleName=&AssumeRolePolicyDocument=&Action=&Version=#Action=CreateRole');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateRole');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'RoleName' => '',
  'AssumeRolePolicyDocument' => '',
  'Action' => '',
  'Version' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateRole');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'RoleName' => '',
  'AssumeRolePolicyDocument' => '',
  'Action' => '',
  'Version' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?RoleName=&AssumeRolePolicyDocument=&Action=&Version=#Action=CreateRole' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?RoleName=&AssumeRolePolicyDocument=&Action=&Version=#Action=CreateRole' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/?RoleName=&AssumeRolePolicyDocument=&Action=&Version=")

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

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

url = "{{baseUrl}}/#Action=CreateRole"

querystring = {"RoleName":"","AssumeRolePolicyDocument":"","Action":"","Version":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateRole"

queryString <- list(
  RoleName = "",
  AssumeRolePolicyDocument = "",
  Action = "",
  Version = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?RoleName=&AssumeRolePolicyDocument=&Action=&Version=#Action=CreateRole")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/') do |req|
  req.params['RoleName'] = ''
  req.params['AssumeRolePolicyDocument'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("RoleName", ""),
        ("AssumeRolePolicyDocument", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?RoleName=&AssumeRolePolicyDocument=&Action=&Version=#Action=CreateRole'
http GET '{{baseUrl}}/?RoleName=&AssumeRolePolicyDocument=&Action=&Version=#Action=CreateRole'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?RoleName=&AssumeRolePolicyDocument=&Action=&Version=#Action=CreateRole'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?RoleName=&AssumeRolePolicyDocument=&Action=&Version=#Action=CreateRole")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "Role": {
    "Arn": "arn:aws:iam::123456789012:role/Test-Role",
    "AssumeRolePolicyDocument": "",
    "CreateDate": "2013-06-07T20:43:32.821Z",
    "Path": "/",
    "RoleId": "AKIAIOSFODNN7EXAMPLE",
    "RoleName": "Test-Role"
  }
}
GET GET_CreateSAMLProvider
{{baseUrl}}/#Action=CreateSAMLProvider
QUERY PARAMS
SAMLMetadataDocument
Name
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?SAMLMetadataDocument=&Name=&Action=&Version=#Action=CreateSAMLProvider");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=CreateSAMLProvider" {:query-params {:SAMLMetadataDocument ""
                                                                                     :Name ""
                                                                                     :Action ""
                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?SAMLMetadataDocument=&Name=&Action=&Version=#Action=CreateSAMLProvider"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?SAMLMetadataDocument=&Name=&Action=&Version=#Action=CreateSAMLProvider"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?SAMLMetadataDocument=&Name=&Action=&Version=#Action=CreateSAMLProvider");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?SAMLMetadataDocument=&Name=&Action=&Version=#Action=CreateSAMLProvider"

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

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

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

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

}
GET /baseUrl/?SAMLMetadataDocument=&Name=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?SAMLMetadataDocument=&Name=&Action=&Version=#Action=CreateSAMLProvider")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?SAMLMetadataDocument=&Name=&Action=&Version=#Action=CreateSAMLProvider"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?SAMLMetadataDocument=&Name=&Action=&Version=#Action=CreateSAMLProvider")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?SAMLMetadataDocument=&Name=&Action=&Version=#Action=CreateSAMLProvider")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/?SAMLMetadataDocument=&Name=&Action=&Version=#Action=CreateSAMLProvider');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateSAMLProvider',
  params: {SAMLMetadataDocument: '', Name: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?SAMLMetadataDocument=&Name=&Action=&Version=#Action=CreateSAMLProvider';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?SAMLMetadataDocument=&Name=&Action=&Version=#Action=CreateSAMLProvider',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?SAMLMetadataDocument=&Name=&Action=&Version=#Action=CreateSAMLProvider")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?SAMLMetadataDocument=&Name=&Action=&Version=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateSAMLProvider',
  qs: {SAMLMetadataDocument: '', Name: '', Action: '', Version: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=CreateSAMLProvider');

req.query({
  SAMLMetadataDocument: '',
  Name: '',
  Action: '',
  Version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateSAMLProvider',
  params: {SAMLMetadataDocument: '', Name: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?SAMLMetadataDocument=&Name=&Action=&Version=#Action=CreateSAMLProvider';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?SAMLMetadataDocument=&Name=&Action=&Version=#Action=CreateSAMLProvider"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/?SAMLMetadataDocument=&Name=&Action=&Version=#Action=CreateSAMLProvider" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?SAMLMetadataDocument=&Name=&Action=&Version=#Action=CreateSAMLProvider",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?SAMLMetadataDocument=&Name=&Action=&Version=#Action=CreateSAMLProvider');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateSAMLProvider');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'SAMLMetadataDocument' => '',
  'Name' => '',
  'Action' => '',
  'Version' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateSAMLProvider');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'SAMLMetadataDocument' => '',
  'Name' => '',
  'Action' => '',
  'Version' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?SAMLMetadataDocument=&Name=&Action=&Version=#Action=CreateSAMLProvider' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?SAMLMetadataDocument=&Name=&Action=&Version=#Action=CreateSAMLProvider' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/?SAMLMetadataDocument=&Name=&Action=&Version=")

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

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

url = "{{baseUrl}}/#Action=CreateSAMLProvider"

querystring = {"SAMLMetadataDocument":"","Name":"","Action":"","Version":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateSAMLProvider"

queryString <- list(
  SAMLMetadataDocument = "",
  Name = "",
  Action = "",
  Version = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?SAMLMetadataDocument=&Name=&Action=&Version=#Action=CreateSAMLProvider")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/') do |req|
  req.params['SAMLMetadataDocument'] = ''
  req.params['Name'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("SAMLMetadataDocument", ""),
        ("Name", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?SAMLMetadataDocument=&Name=&Action=&Version=#Action=CreateSAMLProvider'
http GET '{{baseUrl}}/?SAMLMetadataDocument=&Name=&Action=&Version=#Action=CreateSAMLProvider'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?SAMLMetadataDocument=&Name=&Action=&Version=#Action=CreateSAMLProvider'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?SAMLMetadataDocument=&Name=&Action=&Version=#Action=CreateSAMLProvider")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET GET_CreateServiceLinkedRole
{{baseUrl}}/#Action=CreateServiceLinkedRole
QUERY PARAMS
AWSServiceName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?AWSServiceName=&Action=&Version=#Action=CreateServiceLinkedRole");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=CreateServiceLinkedRole" {:query-params {:AWSServiceName ""
                                                                                          :Action ""
                                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?AWSServiceName=&Action=&Version=#Action=CreateServiceLinkedRole"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?AWSServiceName=&Action=&Version=#Action=CreateServiceLinkedRole"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?AWSServiceName=&Action=&Version=#Action=CreateServiceLinkedRole");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?AWSServiceName=&Action=&Version=#Action=CreateServiceLinkedRole"

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

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

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

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

}
GET /baseUrl/?AWSServiceName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?AWSServiceName=&Action=&Version=#Action=CreateServiceLinkedRole")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?AWSServiceName=&Action=&Version=#Action=CreateServiceLinkedRole"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?AWSServiceName=&Action=&Version=#Action=CreateServiceLinkedRole")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?AWSServiceName=&Action=&Version=#Action=CreateServiceLinkedRole")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/?AWSServiceName=&Action=&Version=#Action=CreateServiceLinkedRole');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateServiceLinkedRole',
  params: {AWSServiceName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?AWSServiceName=&Action=&Version=#Action=CreateServiceLinkedRole';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?AWSServiceName=&Action=&Version=#Action=CreateServiceLinkedRole',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?AWSServiceName=&Action=&Version=#Action=CreateServiceLinkedRole")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?AWSServiceName=&Action=&Version=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateServiceLinkedRole',
  qs: {AWSServiceName: '', Action: '', Version: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=CreateServiceLinkedRole');

req.query({
  AWSServiceName: '',
  Action: '',
  Version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateServiceLinkedRole',
  params: {AWSServiceName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?AWSServiceName=&Action=&Version=#Action=CreateServiceLinkedRole';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?AWSServiceName=&Action=&Version=#Action=CreateServiceLinkedRole"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/?AWSServiceName=&Action=&Version=#Action=CreateServiceLinkedRole" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?AWSServiceName=&Action=&Version=#Action=CreateServiceLinkedRole",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?AWSServiceName=&Action=&Version=#Action=CreateServiceLinkedRole');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateServiceLinkedRole');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'AWSServiceName' => '',
  'Action' => '',
  'Version' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateServiceLinkedRole');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'AWSServiceName' => '',
  'Action' => '',
  'Version' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?AWSServiceName=&Action=&Version=#Action=CreateServiceLinkedRole' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?AWSServiceName=&Action=&Version=#Action=CreateServiceLinkedRole' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/?AWSServiceName=&Action=&Version=")

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

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

url = "{{baseUrl}}/#Action=CreateServiceLinkedRole"

querystring = {"AWSServiceName":"","Action":"","Version":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateServiceLinkedRole"

queryString <- list(
  AWSServiceName = "",
  Action = "",
  Version = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?AWSServiceName=&Action=&Version=#Action=CreateServiceLinkedRole")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/') do |req|
  req.params['AWSServiceName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("AWSServiceName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?AWSServiceName=&Action=&Version=#Action=CreateServiceLinkedRole'
http GET '{{baseUrl}}/?AWSServiceName=&Action=&Version=#Action=CreateServiceLinkedRole'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?AWSServiceName=&Action=&Version=#Action=CreateServiceLinkedRole'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?AWSServiceName=&Action=&Version=#Action=CreateServiceLinkedRole")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET GET_CreateServiceSpecificCredential
{{baseUrl}}/#Action=CreateServiceSpecificCredential
QUERY PARAMS
UserName
ServiceName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?UserName=&ServiceName=&Action=&Version=#Action=CreateServiceSpecificCredential");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=CreateServiceSpecificCredential" {:query-params {:UserName ""
                                                                                                  :ServiceName ""
                                                                                                  :Action ""
                                                                                                  :Version ""}})
require "http/client"

url = "{{baseUrl}}/?UserName=&ServiceName=&Action=&Version=#Action=CreateServiceSpecificCredential"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?UserName=&ServiceName=&Action=&Version=#Action=CreateServiceSpecificCredential"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?UserName=&ServiceName=&Action=&Version=#Action=CreateServiceSpecificCredential");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?UserName=&ServiceName=&Action=&Version=#Action=CreateServiceSpecificCredential"

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

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

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

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

}
GET /baseUrl/?UserName=&ServiceName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?UserName=&ServiceName=&Action=&Version=#Action=CreateServiceSpecificCredential")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?UserName=&ServiceName=&Action=&Version=#Action=CreateServiceSpecificCredential"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?UserName=&ServiceName=&Action=&Version=#Action=CreateServiceSpecificCredential")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?UserName=&ServiceName=&Action=&Version=#Action=CreateServiceSpecificCredential")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/?UserName=&ServiceName=&Action=&Version=#Action=CreateServiceSpecificCredential');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateServiceSpecificCredential',
  params: {UserName: '', ServiceName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?UserName=&ServiceName=&Action=&Version=#Action=CreateServiceSpecificCredential';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?UserName=&ServiceName=&Action=&Version=#Action=CreateServiceSpecificCredential',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?UserName=&ServiceName=&Action=&Version=#Action=CreateServiceSpecificCredential")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?UserName=&ServiceName=&Action=&Version=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateServiceSpecificCredential',
  qs: {UserName: '', ServiceName: '', Action: '', Version: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=CreateServiceSpecificCredential');

req.query({
  UserName: '',
  ServiceName: '',
  Action: '',
  Version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateServiceSpecificCredential',
  params: {UserName: '', ServiceName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?UserName=&ServiceName=&Action=&Version=#Action=CreateServiceSpecificCredential';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?UserName=&ServiceName=&Action=&Version=#Action=CreateServiceSpecificCredential"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/?UserName=&ServiceName=&Action=&Version=#Action=CreateServiceSpecificCredential" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?UserName=&ServiceName=&Action=&Version=#Action=CreateServiceSpecificCredential",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?UserName=&ServiceName=&Action=&Version=#Action=CreateServiceSpecificCredential');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateServiceSpecificCredential');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'UserName' => '',
  'ServiceName' => '',
  'Action' => '',
  'Version' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateServiceSpecificCredential');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'UserName' => '',
  'ServiceName' => '',
  'Action' => '',
  'Version' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?UserName=&ServiceName=&Action=&Version=#Action=CreateServiceSpecificCredential' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?UserName=&ServiceName=&Action=&Version=#Action=CreateServiceSpecificCredential' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/?UserName=&ServiceName=&Action=&Version=")

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

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

url = "{{baseUrl}}/#Action=CreateServiceSpecificCredential"

querystring = {"UserName":"","ServiceName":"","Action":"","Version":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateServiceSpecificCredential"

queryString <- list(
  UserName = "",
  ServiceName = "",
  Action = "",
  Version = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?UserName=&ServiceName=&Action=&Version=#Action=CreateServiceSpecificCredential")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/') do |req|
  req.params['UserName'] = ''
  req.params['ServiceName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("UserName", ""),
        ("ServiceName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?UserName=&ServiceName=&Action=&Version=#Action=CreateServiceSpecificCredential'
http GET '{{baseUrl}}/?UserName=&ServiceName=&Action=&Version=#Action=CreateServiceSpecificCredential'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?UserName=&ServiceName=&Action=&Version=#Action=CreateServiceSpecificCredential'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?UserName=&ServiceName=&Action=&Version=#Action=CreateServiceSpecificCredential")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET GET_CreateUser
{{baseUrl}}/#Action=CreateUser
QUERY PARAMS
UserName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?UserName=&Action=&Version=#Action=CreateUser");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=CreateUser" {:query-params {:UserName ""
                                                                             :Action ""
                                                                             :Version ""}})
require "http/client"

url = "{{baseUrl}}/?UserName=&Action=&Version=#Action=CreateUser"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?UserName=&Action=&Version=#Action=CreateUser"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?UserName=&Action=&Version=#Action=CreateUser");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?UserName=&Action=&Version=#Action=CreateUser"

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

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

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

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

}
GET /baseUrl/?UserName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?UserName=&Action=&Version=#Action=CreateUser")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?UserName=&Action=&Version=#Action=CreateUser"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?UserName=&Action=&Version=#Action=CreateUser")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?UserName=&Action=&Version=#Action=CreateUser")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/?UserName=&Action=&Version=#Action=CreateUser');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateUser',
  params: {UserName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?UserName=&Action=&Version=#Action=CreateUser';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?UserName=&Action=&Version=#Action=CreateUser',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?UserName=&Action=&Version=#Action=CreateUser")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?UserName=&Action=&Version=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateUser',
  qs: {UserName: '', Action: '', Version: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=CreateUser');

req.query({
  UserName: '',
  Action: '',
  Version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateUser',
  params: {UserName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?UserName=&Action=&Version=#Action=CreateUser';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?UserName=&Action=&Version=#Action=CreateUser"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/?UserName=&Action=&Version=#Action=CreateUser" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?UserName=&Action=&Version=#Action=CreateUser",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?UserName=&Action=&Version=#Action=CreateUser');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateUser');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'UserName' => '',
  'Action' => '',
  'Version' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateUser');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'UserName' => '',
  'Action' => '',
  'Version' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?UserName=&Action=&Version=#Action=CreateUser' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?UserName=&Action=&Version=#Action=CreateUser' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/?UserName=&Action=&Version=")

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

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

url = "{{baseUrl}}/#Action=CreateUser"

querystring = {"UserName":"","Action":"","Version":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateUser"

queryString <- list(
  UserName = "",
  Action = "",
  Version = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?UserName=&Action=&Version=#Action=CreateUser")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/') do |req|
  req.params['UserName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("UserName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?UserName=&Action=&Version=#Action=CreateUser'
http GET '{{baseUrl}}/?UserName=&Action=&Version=#Action=CreateUser'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?UserName=&Action=&Version=#Action=CreateUser'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?UserName=&Action=&Version=#Action=CreateUser")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "User": {
    "Arn": "arn:aws:iam::123456789012:user/Bob",
    "CreateDate": "2013-06-08T03:20:41.270Z",
    "Path": "/",
    "UserId": "AKIAIOSFODNN7EXAMPLE",
    "UserName": "Bob"
  }
}
GET GET_CreateVirtualMFADevice
{{baseUrl}}/#Action=CreateVirtualMFADevice
QUERY PARAMS
VirtualMFADeviceName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?VirtualMFADeviceName=&Action=&Version=#Action=CreateVirtualMFADevice");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=CreateVirtualMFADevice" {:query-params {:VirtualMFADeviceName ""
                                                                                         :Action ""
                                                                                         :Version ""}})
require "http/client"

url = "{{baseUrl}}/?VirtualMFADeviceName=&Action=&Version=#Action=CreateVirtualMFADevice"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?VirtualMFADeviceName=&Action=&Version=#Action=CreateVirtualMFADevice"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?VirtualMFADeviceName=&Action=&Version=#Action=CreateVirtualMFADevice");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?VirtualMFADeviceName=&Action=&Version=#Action=CreateVirtualMFADevice"

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

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

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

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

}
GET /baseUrl/?VirtualMFADeviceName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?VirtualMFADeviceName=&Action=&Version=#Action=CreateVirtualMFADevice")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?VirtualMFADeviceName=&Action=&Version=#Action=CreateVirtualMFADevice"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?VirtualMFADeviceName=&Action=&Version=#Action=CreateVirtualMFADevice")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?VirtualMFADeviceName=&Action=&Version=#Action=CreateVirtualMFADevice")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/?VirtualMFADeviceName=&Action=&Version=#Action=CreateVirtualMFADevice');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateVirtualMFADevice',
  params: {VirtualMFADeviceName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?VirtualMFADeviceName=&Action=&Version=#Action=CreateVirtualMFADevice';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?VirtualMFADeviceName=&Action=&Version=#Action=CreateVirtualMFADevice',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?VirtualMFADeviceName=&Action=&Version=#Action=CreateVirtualMFADevice")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?VirtualMFADeviceName=&Action=&Version=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateVirtualMFADevice',
  qs: {VirtualMFADeviceName: '', Action: '', Version: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=CreateVirtualMFADevice');

req.query({
  VirtualMFADeviceName: '',
  Action: '',
  Version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateVirtualMFADevice',
  params: {VirtualMFADeviceName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?VirtualMFADeviceName=&Action=&Version=#Action=CreateVirtualMFADevice';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?VirtualMFADeviceName=&Action=&Version=#Action=CreateVirtualMFADevice"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/?VirtualMFADeviceName=&Action=&Version=#Action=CreateVirtualMFADevice" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?VirtualMFADeviceName=&Action=&Version=#Action=CreateVirtualMFADevice",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?VirtualMFADeviceName=&Action=&Version=#Action=CreateVirtualMFADevice');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateVirtualMFADevice');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'VirtualMFADeviceName' => '',
  'Action' => '',
  'Version' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateVirtualMFADevice');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'VirtualMFADeviceName' => '',
  'Action' => '',
  'Version' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?VirtualMFADeviceName=&Action=&Version=#Action=CreateVirtualMFADevice' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?VirtualMFADeviceName=&Action=&Version=#Action=CreateVirtualMFADevice' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/?VirtualMFADeviceName=&Action=&Version=")

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

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

url = "{{baseUrl}}/#Action=CreateVirtualMFADevice"

querystring = {"VirtualMFADeviceName":"","Action":"","Version":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateVirtualMFADevice"

queryString <- list(
  VirtualMFADeviceName = "",
  Action = "",
  Version = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?VirtualMFADeviceName=&Action=&Version=#Action=CreateVirtualMFADevice")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/') do |req|
  req.params['VirtualMFADeviceName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("VirtualMFADeviceName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?VirtualMFADeviceName=&Action=&Version=#Action=CreateVirtualMFADevice'
http GET '{{baseUrl}}/?VirtualMFADeviceName=&Action=&Version=#Action=CreateVirtualMFADevice'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?VirtualMFADeviceName=&Action=&Version=#Action=CreateVirtualMFADevice'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?VirtualMFADeviceName=&Action=&Version=#Action=CreateVirtualMFADevice")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET GET_DeactivateMFADevice
{{baseUrl}}/#Action=DeactivateMFADevice
QUERY PARAMS
UserName
SerialNumber
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?UserName=&SerialNumber=&Action=&Version=#Action=DeactivateMFADevice");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DeactivateMFADevice" {:query-params {:UserName ""
                                                                                      :SerialNumber ""
                                                                                      :Action ""
                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?UserName=&SerialNumber=&Action=&Version=#Action=DeactivateMFADevice"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?UserName=&SerialNumber=&Action=&Version=#Action=DeactivateMFADevice"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?UserName=&SerialNumber=&Action=&Version=#Action=DeactivateMFADevice");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?UserName=&SerialNumber=&Action=&Version=#Action=DeactivateMFADevice"

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

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

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

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

}
GET /baseUrl/?UserName=&SerialNumber=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?UserName=&SerialNumber=&Action=&Version=#Action=DeactivateMFADevice")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?UserName=&SerialNumber=&Action=&Version=#Action=DeactivateMFADevice"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?UserName=&SerialNumber=&Action=&Version=#Action=DeactivateMFADevice")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?UserName=&SerialNumber=&Action=&Version=#Action=DeactivateMFADevice")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/?UserName=&SerialNumber=&Action=&Version=#Action=DeactivateMFADevice');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeactivateMFADevice',
  params: {UserName: '', SerialNumber: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?UserName=&SerialNumber=&Action=&Version=#Action=DeactivateMFADevice';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?UserName=&SerialNumber=&Action=&Version=#Action=DeactivateMFADevice',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?UserName=&SerialNumber=&Action=&Version=#Action=DeactivateMFADevice")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?UserName=&SerialNumber=&Action=&Version=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeactivateMFADevice',
  qs: {UserName: '', SerialNumber: '', Action: '', Version: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=DeactivateMFADevice');

req.query({
  UserName: '',
  SerialNumber: '',
  Action: '',
  Version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeactivateMFADevice',
  params: {UserName: '', SerialNumber: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?UserName=&SerialNumber=&Action=&Version=#Action=DeactivateMFADevice';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?UserName=&SerialNumber=&Action=&Version=#Action=DeactivateMFADevice"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/?UserName=&SerialNumber=&Action=&Version=#Action=DeactivateMFADevice" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?UserName=&SerialNumber=&Action=&Version=#Action=DeactivateMFADevice",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?UserName=&SerialNumber=&Action=&Version=#Action=DeactivateMFADevice');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeactivateMFADevice');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'UserName' => '',
  'SerialNumber' => '',
  'Action' => '',
  'Version' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeactivateMFADevice');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'UserName' => '',
  'SerialNumber' => '',
  'Action' => '',
  'Version' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?UserName=&SerialNumber=&Action=&Version=#Action=DeactivateMFADevice' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?UserName=&SerialNumber=&Action=&Version=#Action=DeactivateMFADevice' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/?UserName=&SerialNumber=&Action=&Version=")

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

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

url = "{{baseUrl}}/#Action=DeactivateMFADevice"

querystring = {"UserName":"","SerialNumber":"","Action":"","Version":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeactivateMFADevice"

queryString <- list(
  UserName = "",
  SerialNumber = "",
  Action = "",
  Version = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?UserName=&SerialNumber=&Action=&Version=#Action=DeactivateMFADevice")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/') do |req|
  req.params['UserName'] = ''
  req.params['SerialNumber'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("UserName", ""),
        ("SerialNumber", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?UserName=&SerialNumber=&Action=&Version=#Action=DeactivateMFADevice'
http GET '{{baseUrl}}/?UserName=&SerialNumber=&Action=&Version=#Action=DeactivateMFADevice'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?UserName=&SerialNumber=&Action=&Version=#Action=DeactivateMFADevice'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?UserName=&SerialNumber=&Action=&Version=#Action=DeactivateMFADevice")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET GET_DeleteAccessKey
{{baseUrl}}/#Action=DeleteAccessKey
QUERY PARAMS
AccessKeyId
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=DeleteAccessKey");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DeleteAccessKey" {:query-params {:AccessKeyId ""
                                                                                  :Action ""
                                                                                  :Version ""}})
require "http/client"

url = "{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=DeleteAccessKey"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=DeleteAccessKey"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=DeleteAccessKey");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=DeleteAccessKey"

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

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

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

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

}
GET /baseUrl/?AccessKeyId=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=DeleteAccessKey")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=DeleteAccessKey"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=DeleteAccessKey")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=DeleteAccessKey")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=DeleteAccessKey');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteAccessKey',
  params: {AccessKeyId: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=DeleteAccessKey';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=DeleteAccessKey',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=DeleteAccessKey")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?AccessKeyId=&Action=&Version=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteAccessKey',
  qs: {AccessKeyId: '', Action: '', Version: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=DeleteAccessKey');

req.query({
  AccessKeyId: '',
  Action: '',
  Version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteAccessKey',
  params: {AccessKeyId: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=DeleteAccessKey';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=DeleteAccessKey"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=DeleteAccessKey" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=DeleteAccessKey",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=DeleteAccessKey');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteAccessKey');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'AccessKeyId' => '',
  'Action' => '',
  'Version' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteAccessKey');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'AccessKeyId' => '',
  'Action' => '',
  'Version' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=DeleteAccessKey' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=DeleteAccessKey' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/?AccessKeyId=&Action=&Version=")

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

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

url = "{{baseUrl}}/#Action=DeleteAccessKey"

querystring = {"AccessKeyId":"","Action":"","Version":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteAccessKey"

queryString <- list(
  AccessKeyId = "",
  Action = "",
  Version = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=DeleteAccessKey")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/') do |req|
  req.params['AccessKeyId'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("AccessKeyId", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=DeleteAccessKey'
http GET '{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=DeleteAccessKey'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=DeleteAccessKey'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=DeleteAccessKey")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET GET_DeleteAccountAlias
{{baseUrl}}/#Action=DeleteAccountAlias
QUERY PARAMS
AccountAlias
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=DeleteAccountAlias");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DeleteAccountAlias" {:query-params {:AccountAlias ""
                                                                                     :Action ""
                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=DeleteAccountAlias"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=DeleteAccountAlias"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=DeleteAccountAlias");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=DeleteAccountAlias"

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

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

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

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

}
GET /baseUrl/?AccountAlias=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=DeleteAccountAlias")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=DeleteAccountAlias"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=DeleteAccountAlias")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=DeleteAccountAlias")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=DeleteAccountAlias');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteAccountAlias',
  params: {AccountAlias: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=DeleteAccountAlias';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=DeleteAccountAlias',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=DeleteAccountAlias")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?AccountAlias=&Action=&Version=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteAccountAlias',
  qs: {AccountAlias: '', Action: '', Version: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=DeleteAccountAlias');

req.query({
  AccountAlias: '',
  Action: '',
  Version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteAccountAlias',
  params: {AccountAlias: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=DeleteAccountAlias';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=DeleteAccountAlias"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=DeleteAccountAlias" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=DeleteAccountAlias",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=DeleteAccountAlias');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteAccountAlias');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'AccountAlias' => '',
  'Action' => '',
  'Version' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteAccountAlias');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'AccountAlias' => '',
  'Action' => '',
  'Version' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=DeleteAccountAlias' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=DeleteAccountAlias' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/?AccountAlias=&Action=&Version=")

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

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

url = "{{baseUrl}}/#Action=DeleteAccountAlias"

querystring = {"AccountAlias":"","Action":"","Version":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteAccountAlias"

queryString <- list(
  AccountAlias = "",
  Action = "",
  Version = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=DeleteAccountAlias")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/') do |req|
  req.params['AccountAlias'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("AccountAlias", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=DeleteAccountAlias'
http GET '{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=DeleteAccountAlias'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=DeleteAccountAlias'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?AccountAlias=&Action=&Version=#Action=DeleteAccountAlias")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET GET_DeleteAccountPasswordPolicy
{{baseUrl}}/#Action=DeleteAccountPasswordPolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DeleteAccountPasswordPolicy" {:query-params {:Action ""
                                                                                              :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy"

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

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

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

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

}
GET /baseUrl/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteAccountPasswordPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteAccountPasswordPolicy',
  qs: {Action: '', Version: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=DeleteAccountPasswordPolicy');

req.query({
  Action: '',
  Version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteAccountPasswordPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteAccountPasswordPolicy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteAccountPasswordPolicy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/?Action=&Version=")

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

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

url = "{{baseUrl}}/#Action=DeleteAccountPasswordPolicy"

querystring = {"Action":"","Version":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteAccountPasswordPolicy"

queryString <- list(
  Action = "",
  Version = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy'
http GET '{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET GET_DeleteGroup
{{baseUrl}}/#Action=DeleteGroup
QUERY PARAMS
GroupName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?GroupName=&Action=&Version=#Action=DeleteGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DeleteGroup" {:query-params {:GroupName ""
                                                                              :Action ""
                                                                              :Version ""}})
require "http/client"

url = "{{baseUrl}}/?GroupName=&Action=&Version=#Action=DeleteGroup"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?GroupName=&Action=&Version=#Action=DeleteGroup"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?GroupName=&Action=&Version=#Action=DeleteGroup");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?GroupName=&Action=&Version=#Action=DeleteGroup"

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

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

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

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

}
GET /baseUrl/?GroupName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?GroupName=&Action=&Version=#Action=DeleteGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?GroupName=&Action=&Version=#Action=DeleteGroup"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?GroupName=&Action=&Version=#Action=DeleteGroup")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?GroupName=&Action=&Version=#Action=DeleteGroup")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/?GroupName=&Action=&Version=#Action=DeleteGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteGroup',
  params: {GroupName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?GroupName=&Action=&Version=#Action=DeleteGroup';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?GroupName=&Action=&Version=#Action=DeleteGroup',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?GroupName=&Action=&Version=#Action=DeleteGroup")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?GroupName=&Action=&Version=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteGroup',
  qs: {GroupName: '', Action: '', Version: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=DeleteGroup');

req.query({
  GroupName: '',
  Action: '',
  Version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteGroup',
  params: {GroupName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?GroupName=&Action=&Version=#Action=DeleteGroup';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?GroupName=&Action=&Version=#Action=DeleteGroup"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/?GroupName=&Action=&Version=#Action=DeleteGroup" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?GroupName=&Action=&Version=#Action=DeleteGroup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?GroupName=&Action=&Version=#Action=DeleteGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteGroup');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'GroupName' => '',
  'Action' => '',
  'Version' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteGroup');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'GroupName' => '',
  'Action' => '',
  'Version' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?GroupName=&Action=&Version=#Action=DeleteGroup' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?GroupName=&Action=&Version=#Action=DeleteGroup' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/?GroupName=&Action=&Version=")

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

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

url = "{{baseUrl}}/#Action=DeleteGroup"

querystring = {"GroupName":"","Action":"","Version":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteGroup"

queryString <- list(
  GroupName = "",
  Action = "",
  Version = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?GroupName=&Action=&Version=#Action=DeleteGroup")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/') do |req|
  req.params['GroupName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("GroupName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?GroupName=&Action=&Version=#Action=DeleteGroup'
http GET '{{baseUrl}}/?GroupName=&Action=&Version=#Action=DeleteGroup'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?GroupName=&Action=&Version=#Action=DeleteGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?GroupName=&Action=&Version=#Action=DeleteGroup")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET GET_DeleteGroupPolicy
{{baseUrl}}/#Action=DeleteGroupPolicy
QUERY PARAMS
GroupName
PolicyName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=DeleteGroupPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DeleteGroupPolicy" {:query-params {:GroupName ""
                                                                                    :PolicyName ""
                                                                                    :Action ""
                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=DeleteGroupPolicy"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=DeleteGroupPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=DeleteGroupPolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=DeleteGroupPolicy"

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

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

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

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

}
GET /baseUrl/?GroupName=&PolicyName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=DeleteGroupPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=DeleteGroupPolicy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=DeleteGroupPolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=DeleteGroupPolicy")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=DeleteGroupPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteGroupPolicy',
  params: {GroupName: '', PolicyName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=DeleteGroupPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=DeleteGroupPolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=DeleteGroupPolicy")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?GroupName=&PolicyName=&Action=&Version=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteGroupPolicy',
  qs: {GroupName: '', PolicyName: '', Action: '', Version: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=DeleteGroupPolicy');

req.query({
  GroupName: '',
  PolicyName: '',
  Action: '',
  Version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteGroupPolicy',
  params: {GroupName: '', PolicyName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=DeleteGroupPolicy';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=DeleteGroupPolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=DeleteGroupPolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=DeleteGroupPolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=DeleteGroupPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteGroupPolicy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'GroupName' => '',
  'PolicyName' => '',
  'Action' => '',
  'Version' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteGroupPolicy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'GroupName' => '',
  'PolicyName' => '',
  'Action' => '',
  'Version' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=DeleteGroupPolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=DeleteGroupPolicy' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/?GroupName=&PolicyName=&Action=&Version=")

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

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

url = "{{baseUrl}}/#Action=DeleteGroupPolicy"

querystring = {"GroupName":"","PolicyName":"","Action":"","Version":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteGroupPolicy"

queryString <- list(
  GroupName = "",
  PolicyName = "",
  Action = "",
  Version = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=DeleteGroupPolicy")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/') do |req|
  req.params['GroupName'] = ''
  req.params['PolicyName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("GroupName", ""),
        ("PolicyName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=DeleteGroupPolicy'
http GET '{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=DeleteGroupPolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=DeleteGroupPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=DeleteGroupPolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET GET_DeleteInstanceProfile
{{baseUrl}}/#Action=DeleteInstanceProfile
QUERY PARAMS
InstanceProfileName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=DeleteInstanceProfile");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DeleteInstanceProfile" {:query-params {:InstanceProfileName ""
                                                                                        :Action ""
                                                                                        :Version ""}})
require "http/client"

url = "{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=DeleteInstanceProfile"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=DeleteInstanceProfile"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=DeleteInstanceProfile");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=DeleteInstanceProfile"

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

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

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

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

}
GET /baseUrl/?InstanceProfileName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=DeleteInstanceProfile")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=DeleteInstanceProfile"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=DeleteInstanceProfile")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=DeleteInstanceProfile")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=DeleteInstanceProfile');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteInstanceProfile',
  params: {InstanceProfileName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=DeleteInstanceProfile';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=DeleteInstanceProfile',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=DeleteInstanceProfile")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?InstanceProfileName=&Action=&Version=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteInstanceProfile',
  qs: {InstanceProfileName: '', Action: '', Version: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=DeleteInstanceProfile');

req.query({
  InstanceProfileName: '',
  Action: '',
  Version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteInstanceProfile',
  params: {InstanceProfileName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=DeleteInstanceProfile';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=DeleteInstanceProfile"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=DeleteInstanceProfile" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=DeleteInstanceProfile",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=DeleteInstanceProfile');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteInstanceProfile');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'InstanceProfileName' => '',
  'Action' => '',
  'Version' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteInstanceProfile');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'InstanceProfileName' => '',
  'Action' => '',
  'Version' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=DeleteInstanceProfile' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=DeleteInstanceProfile' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/?InstanceProfileName=&Action=&Version=")

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

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

url = "{{baseUrl}}/#Action=DeleteInstanceProfile"

querystring = {"InstanceProfileName":"","Action":"","Version":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteInstanceProfile"

queryString <- list(
  InstanceProfileName = "",
  Action = "",
  Version = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=DeleteInstanceProfile")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/') do |req|
  req.params['InstanceProfileName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("InstanceProfileName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=DeleteInstanceProfile'
http GET '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=DeleteInstanceProfile'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=DeleteInstanceProfile'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=DeleteInstanceProfile")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET GET_DeleteLoginProfile
{{baseUrl}}/#Action=DeleteLoginProfile
QUERY PARAMS
UserName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteLoginProfile");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DeleteLoginProfile" {:query-params {:UserName ""
                                                                                     :Action ""
                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteLoginProfile"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteLoginProfile"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteLoginProfile");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteLoginProfile"

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

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

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

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

}
GET /baseUrl/?UserName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteLoginProfile")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteLoginProfile"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteLoginProfile")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteLoginProfile")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteLoginProfile');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteLoginProfile',
  params: {UserName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteLoginProfile';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteLoginProfile',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteLoginProfile")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?UserName=&Action=&Version=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteLoginProfile',
  qs: {UserName: '', Action: '', Version: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=DeleteLoginProfile');

req.query({
  UserName: '',
  Action: '',
  Version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteLoginProfile',
  params: {UserName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteLoginProfile';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteLoginProfile"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteLoginProfile" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteLoginProfile",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteLoginProfile');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteLoginProfile');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'UserName' => '',
  'Action' => '',
  'Version' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteLoginProfile');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'UserName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteLoginProfile' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteLoginProfile' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?UserName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteLoginProfile"

querystring = {"UserName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteLoginProfile"

queryString <- list(
  UserName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteLoginProfile")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['UserName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteLoginProfile";

    let querystring = [
        ("UserName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteLoginProfile'
http GET '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteLoginProfile'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteLoginProfile'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteLoginProfile")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_DeleteOpenIDConnectProvider
{{baseUrl}}/#Action=DeleteOpenIDConnectProvider
QUERY PARAMS
OpenIDConnectProviderArn
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=DeleteOpenIDConnectProvider");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DeleteOpenIDConnectProvider" {:query-params {:OpenIDConnectProviderArn ""
                                                                                              :Action ""
                                                                                              :Version ""}})
require "http/client"

url = "{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=DeleteOpenIDConnectProvider"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=DeleteOpenIDConnectProvider"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=DeleteOpenIDConnectProvider");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=DeleteOpenIDConnectProvider"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?OpenIDConnectProviderArn=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=DeleteOpenIDConnectProvider")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=DeleteOpenIDConnectProvider"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=DeleteOpenIDConnectProvider")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=DeleteOpenIDConnectProvider")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=DeleteOpenIDConnectProvider');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteOpenIDConnectProvider',
  params: {OpenIDConnectProviderArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=DeleteOpenIDConnectProvider';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=DeleteOpenIDConnectProvider',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=DeleteOpenIDConnectProvider")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?OpenIDConnectProviderArn=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteOpenIDConnectProvider',
  qs: {OpenIDConnectProviderArn: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=DeleteOpenIDConnectProvider');

req.query({
  OpenIDConnectProviderArn: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteOpenIDConnectProvider',
  params: {OpenIDConnectProviderArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=DeleteOpenIDConnectProvider';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=DeleteOpenIDConnectProvider"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=DeleteOpenIDConnectProvider" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=DeleteOpenIDConnectProvider",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=DeleteOpenIDConnectProvider');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteOpenIDConnectProvider');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'OpenIDConnectProviderArn' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteOpenIDConnectProvider');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'OpenIDConnectProviderArn' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=DeleteOpenIDConnectProvider' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=DeleteOpenIDConnectProvider' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?OpenIDConnectProviderArn=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteOpenIDConnectProvider"

querystring = {"OpenIDConnectProviderArn":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteOpenIDConnectProvider"

queryString <- list(
  OpenIDConnectProviderArn = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=DeleteOpenIDConnectProvider")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['OpenIDConnectProviderArn'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteOpenIDConnectProvider";

    let querystring = [
        ("OpenIDConnectProviderArn", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=DeleteOpenIDConnectProvider'
http GET '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=DeleteOpenIDConnectProvider'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=DeleteOpenIDConnectProvider'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=DeleteOpenIDConnectProvider")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_DeletePolicy
{{baseUrl}}/#Action=DeletePolicy
QUERY PARAMS
PolicyArn
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=DeletePolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DeletePolicy" {:query-params {:PolicyArn ""
                                                                               :Action ""
                                                                               :Version ""}})
require "http/client"

url = "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=DeletePolicy"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=DeletePolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=DeletePolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=DeletePolicy"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?PolicyArn=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=DeletePolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=DeletePolicy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=DeletePolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=DeletePolicy")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=DeletePolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeletePolicy',
  params: {PolicyArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=DeletePolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=DeletePolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=DeletePolicy")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?PolicyArn=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeletePolicy',
  qs: {PolicyArn: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=DeletePolicy');

req.query({
  PolicyArn: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeletePolicy',
  params: {PolicyArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=DeletePolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=DeletePolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=DeletePolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=DeletePolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=DeletePolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeletePolicy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'PolicyArn' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeletePolicy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'PolicyArn' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=DeletePolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=DeletePolicy' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?PolicyArn=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeletePolicy"

querystring = {"PolicyArn":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeletePolicy"

queryString <- list(
  PolicyArn = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=DeletePolicy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['PolicyArn'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeletePolicy";

    let querystring = [
        ("PolicyArn", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=DeletePolicy'
http GET '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=DeletePolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=DeletePolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=DeletePolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_DeletePolicyVersion
{{baseUrl}}/#Action=DeletePolicyVersion
QUERY PARAMS
PolicyArn
VersionId
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=DeletePolicyVersion");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DeletePolicyVersion" {:query-params {:PolicyArn ""
                                                                                      :VersionId ""
                                                                                      :Action ""
                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=DeletePolicyVersion"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=DeletePolicyVersion"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=DeletePolicyVersion");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=DeletePolicyVersion"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?PolicyArn=&VersionId=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=DeletePolicyVersion")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=DeletePolicyVersion"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=DeletePolicyVersion")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=DeletePolicyVersion")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=DeletePolicyVersion');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeletePolicyVersion',
  params: {PolicyArn: '', VersionId: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=DeletePolicyVersion';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=DeletePolicyVersion',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=DeletePolicyVersion")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?PolicyArn=&VersionId=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeletePolicyVersion',
  qs: {PolicyArn: '', VersionId: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=DeletePolicyVersion');

req.query({
  PolicyArn: '',
  VersionId: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeletePolicyVersion',
  params: {PolicyArn: '', VersionId: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=DeletePolicyVersion';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=DeletePolicyVersion"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=DeletePolicyVersion" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=DeletePolicyVersion",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=DeletePolicyVersion');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeletePolicyVersion');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'PolicyArn' => '',
  'VersionId' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeletePolicyVersion');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'PolicyArn' => '',
  'VersionId' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=DeletePolicyVersion' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=DeletePolicyVersion' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?PolicyArn=&VersionId=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeletePolicyVersion"

querystring = {"PolicyArn":"","VersionId":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeletePolicyVersion"

queryString <- list(
  PolicyArn = "",
  VersionId = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=DeletePolicyVersion")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['PolicyArn'] = ''
  req.params['VersionId'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeletePolicyVersion";

    let querystring = [
        ("PolicyArn", ""),
        ("VersionId", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=DeletePolicyVersion'
http GET '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=DeletePolicyVersion'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=DeletePolicyVersion'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=DeletePolicyVersion")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_DeleteRole
{{baseUrl}}/#Action=DeleteRole
QUERY PARAMS
RoleName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRole");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DeleteRole" {:query-params {:RoleName ""
                                                                             :Action ""
                                                                             :Version ""}})
require "http/client"

url = "{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRole"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRole"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRole");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRole"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?RoleName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRole")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRole"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRole")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRole")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRole');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteRole',
  params: {RoleName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRole';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRole',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRole")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?RoleName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteRole',
  qs: {RoleName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=DeleteRole');

req.query({
  RoleName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteRole',
  params: {RoleName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRole';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRole"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRole" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRole",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRole');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteRole');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'RoleName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteRole');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'RoleName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRole' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRole' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?RoleName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteRole"

querystring = {"RoleName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteRole"

queryString <- list(
  RoleName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRole")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['RoleName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteRole";

    let querystring = [
        ("RoleName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRole'
http GET '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRole'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRole'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRole")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_DeleteRolePermissionsBoundary
{{baseUrl}}/#Action=DeleteRolePermissionsBoundary
QUERY PARAMS
RoleName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRolePermissionsBoundary");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DeleteRolePermissionsBoundary" {:query-params {:RoleName ""
                                                                                                :Action ""
                                                                                                :Version ""}})
require "http/client"

url = "{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRolePermissionsBoundary"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRolePermissionsBoundary"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRolePermissionsBoundary");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRolePermissionsBoundary"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?RoleName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRolePermissionsBoundary")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRolePermissionsBoundary"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRolePermissionsBoundary")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRolePermissionsBoundary")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRolePermissionsBoundary');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteRolePermissionsBoundary',
  params: {RoleName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRolePermissionsBoundary';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRolePermissionsBoundary',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRolePermissionsBoundary")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?RoleName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteRolePermissionsBoundary',
  qs: {RoleName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=DeleteRolePermissionsBoundary');

req.query({
  RoleName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteRolePermissionsBoundary',
  params: {RoleName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRolePermissionsBoundary';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRolePermissionsBoundary"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRolePermissionsBoundary" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRolePermissionsBoundary",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRolePermissionsBoundary');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteRolePermissionsBoundary');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'RoleName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteRolePermissionsBoundary');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'RoleName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRolePermissionsBoundary' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRolePermissionsBoundary' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?RoleName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteRolePermissionsBoundary"

querystring = {"RoleName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteRolePermissionsBoundary"

queryString <- list(
  RoleName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRolePermissionsBoundary")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['RoleName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteRolePermissionsBoundary";

    let querystring = [
        ("RoleName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRolePermissionsBoundary'
http GET '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRolePermissionsBoundary'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRolePermissionsBoundary'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteRolePermissionsBoundary")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_DeleteRolePolicy
{{baseUrl}}/#Action=DeleteRolePolicy
QUERY PARAMS
RoleName
PolicyName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=DeleteRolePolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DeleteRolePolicy" {:query-params {:RoleName ""
                                                                                   :PolicyName ""
                                                                                   :Action ""
                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=DeleteRolePolicy"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=DeleteRolePolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=DeleteRolePolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=DeleteRolePolicy"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?RoleName=&PolicyName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=DeleteRolePolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=DeleteRolePolicy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=DeleteRolePolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=DeleteRolePolicy")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=DeleteRolePolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteRolePolicy',
  params: {RoleName: '', PolicyName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=DeleteRolePolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=DeleteRolePolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=DeleteRolePolicy")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?RoleName=&PolicyName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteRolePolicy',
  qs: {RoleName: '', PolicyName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=DeleteRolePolicy');

req.query({
  RoleName: '',
  PolicyName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteRolePolicy',
  params: {RoleName: '', PolicyName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=DeleteRolePolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=DeleteRolePolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=DeleteRolePolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=DeleteRolePolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=DeleteRolePolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteRolePolicy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'RoleName' => '',
  'PolicyName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteRolePolicy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'RoleName' => '',
  'PolicyName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=DeleteRolePolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=DeleteRolePolicy' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?RoleName=&PolicyName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteRolePolicy"

querystring = {"RoleName":"","PolicyName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteRolePolicy"

queryString <- list(
  RoleName = "",
  PolicyName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=DeleteRolePolicy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['RoleName'] = ''
  req.params['PolicyName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteRolePolicy";

    let querystring = [
        ("RoleName", ""),
        ("PolicyName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=DeleteRolePolicy'
http GET '{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=DeleteRolePolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=DeleteRolePolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=DeleteRolePolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_DeleteSAMLProvider
{{baseUrl}}/#Action=DeleteSAMLProvider
QUERY PARAMS
SAMLProviderArn
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=DeleteSAMLProvider");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DeleteSAMLProvider" {:query-params {:SAMLProviderArn ""
                                                                                     :Action ""
                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=DeleteSAMLProvider"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=DeleteSAMLProvider"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=DeleteSAMLProvider");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=DeleteSAMLProvider"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?SAMLProviderArn=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=DeleteSAMLProvider")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=DeleteSAMLProvider"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=DeleteSAMLProvider")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=DeleteSAMLProvider")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=DeleteSAMLProvider');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteSAMLProvider',
  params: {SAMLProviderArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=DeleteSAMLProvider';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=DeleteSAMLProvider',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=DeleteSAMLProvider")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?SAMLProviderArn=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteSAMLProvider',
  qs: {SAMLProviderArn: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=DeleteSAMLProvider');

req.query({
  SAMLProviderArn: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteSAMLProvider',
  params: {SAMLProviderArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=DeleteSAMLProvider';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=DeleteSAMLProvider"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=DeleteSAMLProvider" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=DeleteSAMLProvider",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=DeleteSAMLProvider');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteSAMLProvider');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'SAMLProviderArn' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteSAMLProvider');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'SAMLProviderArn' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=DeleteSAMLProvider' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=DeleteSAMLProvider' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?SAMLProviderArn=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteSAMLProvider"

querystring = {"SAMLProviderArn":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteSAMLProvider"

queryString <- list(
  SAMLProviderArn = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=DeleteSAMLProvider")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['SAMLProviderArn'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteSAMLProvider";

    let querystring = [
        ("SAMLProviderArn", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=DeleteSAMLProvider'
http GET '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=DeleteSAMLProvider'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=DeleteSAMLProvider'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=DeleteSAMLProvider")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_DeleteSSHPublicKey
{{baseUrl}}/#Action=DeleteSSHPublicKey
QUERY PARAMS
UserName
SSHPublicKeyId
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?UserName=&SSHPublicKeyId=&Action=&Version=#Action=DeleteSSHPublicKey");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DeleteSSHPublicKey" {:query-params {:UserName ""
                                                                                     :SSHPublicKeyId ""
                                                                                     :Action ""
                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?UserName=&SSHPublicKeyId=&Action=&Version=#Action=DeleteSSHPublicKey"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?UserName=&SSHPublicKeyId=&Action=&Version=#Action=DeleteSSHPublicKey"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?UserName=&SSHPublicKeyId=&Action=&Version=#Action=DeleteSSHPublicKey");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?UserName=&SSHPublicKeyId=&Action=&Version=#Action=DeleteSSHPublicKey"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?UserName=&SSHPublicKeyId=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?UserName=&SSHPublicKeyId=&Action=&Version=#Action=DeleteSSHPublicKey")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?UserName=&SSHPublicKeyId=&Action=&Version=#Action=DeleteSSHPublicKey"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?UserName=&SSHPublicKeyId=&Action=&Version=#Action=DeleteSSHPublicKey")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?UserName=&SSHPublicKeyId=&Action=&Version=#Action=DeleteSSHPublicKey")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Action=&Version=#Action=DeleteSSHPublicKey');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteSSHPublicKey',
  params: {UserName: '', SSHPublicKeyId: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Action=&Version=#Action=DeleteSSHPublicKey';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Action=&Version=#Action=DeleteSSHPublicKey',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?UserName=&SSHPublicKeyId=&Action=&Version=#Action=DeleteSSHPublicKey")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?UserName=&SSHPublicKeyId=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteSSHPublicKey',
  qs: {UserName: '', SSHPublicKeyId: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=DeleteSSHPublicKey');

req.query({
  UserName: '',
  SSHPublicKeyId: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteSSHPublicKey',
  params: {UserName: '', SSHPublicKeyId: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Action=&Version=#Action=DeleteSSHPublicKey';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?UserName=&SSHPublicKeyId=&Action=&Version=#Action=DeleteSSHPublicKey"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?UserName=&SSHPublicKeyId=&Action=&Version=#Action=DeleteSSHPublicKey" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?UserName=&SSHPublicKeyId=&Action=&Version=#Action=DeleteSSHPublicKey",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Action=&Version=#Action=DeleteSSHPublicKey');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteSSHPublicKey');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'UserName' => '',
  'SSHPublicKeyId' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteSSHPublicKey');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'UserName' => '',
  'SSHPublicKeyId' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Action=&Version=#Action=DeleteSSHPublicKey' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Action=&Version=#Action=DeleteSSHPublicKey' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?UserName=&SSHPublicKeyId=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteSSHPublicKey"

querystring = {"UserName":"","SSHPublicKeyId":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteSSHPublicKey"

queryString <- list(
  UserName = "",
  SSHPublicKeyId = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?UserName=&SSHPublicKeyId=&Action=&Version=#Action=DeleteSSHPublicKey")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['UserName'] = ''
  req.params['SSHPublicKeyId'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteSSHPublicKey";

    let querystring = [
        ("UserName", ""),
        ("SSHPublicKeyId", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Action=&Version=#Action=DeleteSSHPublicKey'
http GET '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Action=&Version=#Action=DeleteSSHPublicKey'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Action=&Version=#Action=DeleteSSHPublicKey'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?UserName=&SSHPublicKeyId=&Action=&Version=#Action=DeleteSSHPublicKey")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_DeleteServerCertificate
{{baseUrl}}/#Action=DeleteServerCertificate
QUERY PARAMS
ServerCertificateName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=DeleteServerCertificate");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DeleteServerCertificate" {:query-params {:ServerCertificateName ""
                                                                                          :Action ""
                                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=DeleteServerCertificate"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=DeleteServerCertificate"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=DeleteServerCertificate");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=DeleteServerCertificate"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?ServerCertificateName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=DeleteServerCertificate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=DeleteServerCertificate"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=DeleteServerCertificate")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=DeleteServerCertificate")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=DeleteServerCertificate');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteServerCertificate',
  params: {ServerCertificateName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=DeleteServerCertificate';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=DeleteServerCertificate',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=DeleteServerCertificate")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?ServerCertificateName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteServerCertificate',
  qs: {ServerCertificateName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=DeleteServerCertificate');

req.query({
  ServerCertificateName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteServerCertificate',
  params: {ServerCertificateName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=DeleteServerCertificate';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=DeleteServerCertificate"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=DeleteServerCertificate" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=DeleteServerCertificate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=DeleteServerCertificate');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteServerCertificate');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'ServerCertificateName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteServerCertificate');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'ServerCertificateName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=DeleteServerCertificate' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=DeleteServerCertificate' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?ServerCertificateName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteServerCertificate"

querystring = {"ServerCertificateName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteServerCertificate"

queryString <- list(
  ServerCertificateName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=DeleteServerCertificate")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['ServerCertificateName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteServerCertificate";

    let querystring = [
        ("ServerCertificateName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=DeleteServerCertificate'
http GET '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=DeleteServerCertificate'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=DeleteServerCertificate'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=DeleteServerCertificate")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_DeleteServiceLinkedRole
{{baseUrl}}/#Action=DeleteServiceLinkedRole
QUERY PARAMS
RoleName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteServiceLinkedRole");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DeleteServiceLinkedRole" {:query-params {:RoleName ""
                                                                                          :Action ""
                                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteServiceLinkedRole"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteServiceLinkedRole"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteServiceLinkedRole");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteServiceLinkedRole"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?RoleName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteServiceLinkedRole")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteServiceLinkedRole"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteServiceLinkedRole")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteServiceLinkedRole")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteServiceLinkedRole');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteServiceLinkedRole',
  params: {RoleName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteServiceLinkedRole';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteServiceLinkedRole',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteServiceLinkedRole")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?RoleName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteServiceLinkedRole',
  qs: {RoleName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=DeleteServiceLinkedRole');

req.query({
  RoleName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteServiceLinkedRole',
  params: {RoleName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteServiceLinkedRole';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteServiceLinkedRole"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteServiceLinkedRole" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteServiceLinkedRole",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteServiceLinkedRole');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteServiceLinkedRole');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'RoleName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteServiceLinkedRole');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'RoleName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteServiceLinkedRole' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteServiceLinkedRole' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?RoleName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteServiceLinkedRole"

querystring = {"RoleName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteServiceLinkedRole"

queryString <- list(
  RoleName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteServiceLinkedRole")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['RoleName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteServiceLinkedRole";

    let querystring = [
        ("RoleName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteServiceLinkedRole'
http GET '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteServiceLinkedRole'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteServiceLinkedRole'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?RoleName=&Action=&Version=#Action=DeleteServiceLinkedRole")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_DeleteServiceSpecificCredential
{{baseUrl}}/#Action=DeleteServiceSpecificCredential
QUERY PARAMS
ServiceSpecificCredentialId
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=DeleteServiceSpecificCredential");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DeleteServiceSpecificCredential" {:query-params {:ServiceSpecificCredentialId ""
                                                                                                  :Action ""
                                                                                                  :Version ""}})
require "http/client"

url = "{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=DeleteServiceSpecificCredential"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=DeleteServiceSpecificCredential"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=DeleteServiceSpecificCredential");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=DeleteServiceSpecificCredential"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?ServiceSpecificCredentialId=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=DeleteServiceSpecificCredential")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=DeleteServiceSpecificCredential"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=DeleteServiceSpecificCredential")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=DeleteServiceSpecificCredential")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=DeleteServiceSpecificCredential');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteServiceSpecificCredential',
  params: {ServiceSpecificCredentialId: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=DeleteServiceSpecificCredential';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=DeleteServiceSpecificCredential',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=DeleteServiceSpecificCredential")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?ServiceSpecificCredentialId=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteServiceSpecificCredential',
  qs: {ServiceSpecificCredentialId: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=DeleteServiceSpecificCredential');

req.query({
  ServiceSpecificCredentialId: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteServiceSpecificCredential',
  params: {ServiceSpecificCredentialId: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=DeleteServiceSpecificCredential';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=DeleteServiceSpecificCredential"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=DeleteServiceSpecificCredential" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=DeleteServiceSpecificCredential",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=DeleteServiceSpecificCredential');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteServiceSpecificCredential');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'ServiceSpecificCredentialId' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteServiceSpecificCredential');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'ServiceSpecificCredentialId' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=DeleteServiceSpecificCredential' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=DeleteServiceSpecificCredential' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?ServiceSpecificCredentialId=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteServiceSpecificCredential"

querystring = {"ServiceSpecificCredentialId":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteServiceSpecificCredential"

queryString <- list(
  ServiceSpecificCredentialId = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=DeleteServiceSpecificCredential")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['ServiceSpecificCredentialId'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteServiceSpecificCredential";

    let querystring = [
        ("ServiceSpecificCredentialId", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=DeleteServiceSpecificCredential'
http GET '{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=DeleteServiceSpecificCredential'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=DeleteServiceSpecificCredential'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=DeleteServiceSpecificCredential")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_DeleteSigningCertificate
{{baseUrl}}/#Action=DeleteSigningCertificate
QUERY PARAMS
CertificateId
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?CertificateId=&Action=&Version=#Action=DeleteSigningCertificate");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DeleteSigningCertificate" {:query-params {:CertificateId ""
                                                                                           :Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?CertificateId=&Action=&Version=#Action=DeleteSigningCertificate"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?CertificateId=&Action=&Version=#Action=DeleteSigningCertificate"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?CertificateId=&Action=&Version=#Action=DeleteSigningCertificate");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?CertificateId=&Action=&Version=#Action=DeleteSigningCertificate"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?CertificateId=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?CertificateId=&Action=&Version=#Action=DeleteSigningCertificate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?CertificateId=&Action=&Version=#Action=DeleteSigningCertificate"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?CertificateId=&Action=&Version=#Action=DeleteSigningCertificate")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?CertificateId=&Action=&Version=#Action=DeleteSigningCertificate")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?CertificateId=&Action=&Version=#Action=DeleteSigningCertificate');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteSigningCertificate',
  params: {CertificateId: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?CertificateId=&Action=&Version=#Action=DeleteSigningCertificate';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?CertificateId=&Action=&Version=#Action=DeleteSigningCertificate',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?CertificateId=&Action=&Version=#Action=DeleteSigningCertificate")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?CertificateId=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteSigningCertificate',
  qs: {CertificateId: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=DeleteSigningCertificate');

req.query({
  CertificateId: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteSigningCertificate',
  params: {CertificateId: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?CertificateId=&Action=&Version=#Action=DeleteSigningCertificate';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?CertificateId=&Action=&Version=#Action=DeleteSigningCertificate"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?CertificateId=&Action=&Version=#Action=DeleteSigningCertificate" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?CertificateId=&Action=&Version=#Action=DeleteSigningCertificate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?CertificateId=&Action=&Version=#Action=DeleteSigningCertificate');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteSigningCertificate');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'CertificateId' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteSigningCertificate');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'CertificateId' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?CertificateId=&Action=&Version=#Action=DeleteSigningCertificate' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?CertificateId=&Action=&Version=#Action=DeleteSigningCertificate' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?CertificateId=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteSigningCertificate"

querystring = {"CertificateId":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteSigningCertificate"

queryString <- list(
  CertificateId = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?CertificateId=&Action=&Version=#Action=DeleteSigningCertificate")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['CertificateId'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteSigningCertificate";

    let querystring = [
        ("CertificateId", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?CertificateId=&Action=&Version=#Action=DeleteSigningCertificate'
http GET '{{baseUrl}}/?CertificateId=&Action=&Version=#Action=DeleteSigningCertificate'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?CertificateId=&Action=&Version=#Action=DeleteSigningCertificate'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?CertificateId=&Action=&Version=#Action=DeleteSigningCertificate")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_DeleteUser
{{baseUrl}}/#Action=DeleteUser
QUERY PARAMS
UserName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUser");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DeleteUser" {:query-params {:UserName ""
                                                                             :Action ""
                                                                             :Version ""}})
require "http/client"

url = "{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUser"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUser"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUser");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUser"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?UserName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUser")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUser"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUser")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUser")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUser');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteUser',
  params: {UserName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUser';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUser',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUser")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?UserName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteUser',
  qs: {UserName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=DeleteUser');

req.query({
  UserName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteUser',
  params: {UserName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUser';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUser"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUser" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUser",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUser');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteUser');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'UserName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteUser');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'UserName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUser' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUser' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?UserName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteUser"

querystring = {"UserName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteUser"

queryString <- list(
  UserName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUser")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['UserName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteUser";

    let querystring = [
        ("UserName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUser'
http GET '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUser'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUser'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUser")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_DeleteUserPermissionsBoundary
{{baseUrl}}/#Action=DeleteUserPermissionsBoundary
QUERY PARAMS
UserName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUserPermissionsBoundary");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DeleteUserPermissionsBoundary" {:query-params {:UserName ""
                                                                                                :Action ""
                                                                                                :Version ""}})
require "http/client"

url = "{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUserPermissionsBoundary"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUserPermissionsBoundary"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUserPermissionsBoundary");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUserPermissionsBoundary"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?UserName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUserPermissionsBoundary")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUserPermissionsBoundary"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUserPermissionsBoundary")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUserPermissionsBoundary")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUserPermissionsBoundary');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteUserPermissionsBoundary',
  params: {UserName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUserPermissionsBoundary';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUserPermissionsBoundary',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUserPermissionsBoundary")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?UserName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteUserPermissionsBoundary',
  qs: {UserName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=DeleteUserPermissionsBoundary');

req.query({
  UserName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteUserPermissionsBoundary',
  params: {UserName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUserPermissionsBoundary';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUserPermissionsBoundary"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUserPermissionsBoundary" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUserPermissionsBoundary",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUserPermissionsBoundary');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteUserPermissionsBoundary');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'UserName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteUserPermissionsBoundary');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'UserName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUserPermissionsBoundary' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUserPermissionsBoundary' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?UserName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteUserPermissionsBoundary"

querystring = {"UserName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteUserPermissionsBoundary"

queryString <- list(
  UserName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUserPermissionsBoundary")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['UserName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteUserPermissionsBoundary";

    let querystring = [
        ("UserName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUserPermissionsBoundary'
http GET '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUserPermissionsBoundary'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUserPermissionsBoundary'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?UserName=&Action=&Version=#Action=DeleteUserPermissionsBoundary")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_DeleteUserPolicy
{{baseUrl}}/#Action=DeleteUserPolicy
QUERY PARAMS
UserName
PolicyName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=DeleteUserPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DeleteUserPolicy" {:query-params {:UserName ""
                                                                                   :PolicyName ""
                                                                                   :Action ""
                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=DeleteUserPolicy"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=DeleteUserPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=DeleteUserPolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=DeleteUserPolicy"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?UserName=&PolicyName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=DeleteUserPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=DeleteUserPolicy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=DeleteUserPolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=DeleteUserPolicy")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=DeleteUserPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteUserPolicy',
  params: {UserName: '', PolicyName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=DeleteUserPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=DeleteUserPolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=DeleteUserPolicy")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?UserName=&PolicyName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteUserPolicy',
  qs: {UserName: '', PolicyName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=DeleteUserPolicy');

req.query({
  UserName: '',
  PolicyName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteUserPolicy',
  params: {UserName: '', PolicyName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=DeleteUserPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=DeleteUserPolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=DeleteUserPolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=DeleteUserPolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=DeleteUserPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteUserPolicy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'UserName' => '',
  'PolicyName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteUserPolicy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'UserName' => '',
  'PolicyName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=DeleteUserPolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=DeleteUserPolicy' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?UserName=&PolicyName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteUserPolicy"

querystring = {"UserName":"","PolicyName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteUserPolicy"

queryString <- list(
  UserName = "",
  PolicyName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=DeleteUserPolicy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['UserName'] = ''
  req.params['PolicyName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteUserPolicy";

    let querystring = [
        ("UserName", ""),
        ("PolicyName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=DeleteUserPolicy'
http GET '{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=DeleteUserPolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=DeleteUserPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=DeleteUserPolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_DeleteVirtualMFADevice
{{baseUrl}}/#Action=DeleteVirtualMFADevice
QUERY PARAMS
SerialNumber
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=DeleteVirtualMFADevice");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DeleteVirtualMFADevice" {:query-params {:SerialNumber ""
                                                                                         :Action ""
                                                                                         :Version ""}})
require "http/client"

url = "{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=DeleteVirtualMFADevice"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=DeleteVirtualMFADevice"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=DeleteVirtualMFADevice");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=DeleteVirtualMFADevice"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?SerialNumber=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=DeleteVirtualMFADevice")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=DeleteVirtualMFADevice"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=DeleteVirtualMFADevice")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=DeleteVirtualMFADevice")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=DeleteVirtualMFADevice');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteVirtualMFADevice',
  params: {SerialNumber: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=DeleteVirtualMFADevice';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=DeleteVirtualMFADevice',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=DeleteVirtualMFADevice")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?SerialNumber=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteVirtualMFADevice',
  qs: {SerialNumber: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=DeleteVirtualMFADevice');

req.query({
  SerialNumber: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DeleteVirtualMFADevice',
  params: {SerialNumber: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=DeleteVirtualMFADevice';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=DeleteVirtualMFADevice"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=DeleteVirtualMFADevice" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=DeleteVirtualMFADevice",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=DeleteVirtualMFADevice');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteVirtualMFADevice');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'SerialNumber' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteVirtualMFADevice');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'SerialNumber' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=DeleteVirtualMFADevice' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=DeleteVirtualMFADevice' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?SerialNumber=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteVirtualMFADevice"

querystring = {"SerialNumber":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteVirtualMFADevice"

queryString <- list(
  SerialNumber = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=DeleteVirtualMFADevice")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['SerialNumber'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteVirtualMFADevice";

    let querystring = [
        ("SerialNumber", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=DeleteVirtualMFADevice'
http GET '{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=DeleteVirtualMFADevice'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=DeleteVirtualMFADevice'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=DeleteVirtualMFADevice")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_DetachGroupPolicy
{{baseUrl}}/#Action=DetachGroupPolicy
QUERY PARAMS
GroupName
PolicyArn
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=DetachGroupPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DetachGroupPolicy" {:query-params {:GroupName ""
                                                                                    :PolicyArn ""
                                                                                    :Action ""
                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=DetachGroupPolicy"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=DetachGroupPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=DetachGroupPolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=DetachGroupPolicy"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?GroupName=&PolicyArn=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=DetachGroupPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=DetachGroupPolicy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=DetachGroupPolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=DetachGroupPolicy")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=DetachGroupPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DetachGroupPolicy',
  params: {GroupName: '', PolicyArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=DetachGroupPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=DetachGroupPolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=DetachGroupPolicy")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?GroupName=&PolicyArn=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DetachGroupPolicy',
  qs: {GroupName: '', PolicyArn: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=DetachGroupPolicy');

req.query({
  GroupName: '',
  PolicyArn: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DetachGroupPolicy',
  params: {GroupName: '', PolicyArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=DetachGroupPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=DetachGroupPolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=DetachGroupPolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=DetachGroupPolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=DetachGroupPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DetachGroupPolicy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'GroupName' => '',
  'PolicyArn' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DetachGroupPolicy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'GroupName' => '',
  'PolicyArn' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=DetachGroupPolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=DetachGroupPolicy' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?GroupName=&PolicyArn=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DetachGroupPolicy"

querystring = {"GroupName":"","PolicyArn":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DetachGroupPolicy"

queryString <- list(
  GroupName = "",
  PolicyArn = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=DetachGroupPolicy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['GroupName'] = ''
  req.params['PolicyArn'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DetachGroupPolicy";

    let querystring = [
        ("GroupName", ""),
        ("PolicyArn", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=DetachGroupPolicy'
http GET '{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=DetachGroupPolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=DetachGroupPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?GroupName=&PolicyArn=&Action=&Version=#Action=DetachGroupPolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_DetachRolePolicy
{{baseUrl}}/#Action=DetachRolePolicy
QUERY PARAMS
RoleName
PolicyArn
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=DetachRolePolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DetachRolePolicy" {:query-params {:RoleName ""
                                                                                   :PolicyArn ""
                                                                                   :Action ""
                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=DetachRolePolicy"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=DetachRolePolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=DetachRolePolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=DetachRolePolicy"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?RoleName=&PolicyArn=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=DetachRolePolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=DetachRolePolicy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=DetachRolePolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=DetachRolePolicy")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=DetachRolePolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DetachRolePolicy',
  params: {RoleName: '', PolicyArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=DetachRolePolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=DetachRolePolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=DetachRolePolicy")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?RoleName=&PolicyArn=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DetachRolePolicy',
  qs: {RoleName: '', PolicyArn: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=DetachRolePolicy');

req.query({
  RoleName: '',
  PolicyArn: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DetachRolePolicy',
  params: {RoleName: '', PolicyArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=DetachRolePolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=DetachRolePolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=DetachRolePolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=DetachRolePolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=DetachRolePolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DetachRolePolicy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'RoleName' => '',
  'PolicyArn' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DetachRolePolicy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'RoleName' => '',
  'PolicyArn' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=DetachRolePolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=DetachRolePolicy' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?RoleName=&PolicyArn=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DetachRolePolicy"

querystring = {"RoleName":"","PolicyArn":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DetachRolePolicy"

queryString <- list(
  RoleName = "",
  PolicyArn = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=DetachRolePolicy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['RoleName'] = ''
  req.params['PolicyArn'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DetachRolePolicy";

    let querystring = [
        ("RoleName", ""),
        ("PolicyArn", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=DetachRolePolicy'
http GET '{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=DetachRolePolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=DetachRolePolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?RoleName=&PolicyArn=&Action=&Version=#Action=DetachRolePolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_DetachUserPolicy
{{baseUrl}}/#Action=DetachUserPolicy
QUERY PARAMS
UserName
PolicyArn
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=DetachUserPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DetachUserPolicy" {:query-params {:UserName ""
                                                                                   :PolicyArn ""
                                                                                   :Action ""
                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=DetachUserPolicy"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=DetachUserPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=DetachUserPolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=DetachUserPolicy"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?UserName=&PolicyArn=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=DetachUserPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=DetachUserPolicy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=DetachUserPolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=DetachUserPolicy")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=DetachUserPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DetachUserPolicy',
  params: {UserName: '', PolicyArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=DetachUserPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=DetachUserPolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=DetachUserPolicy")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?UserName=&PolicyArn=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DetachUserPolicy',
  qs: {UserName: '', PolicyArn: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=DetachUserPolicy');

req.query({
  UserName: '',
  PolicyArn: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DetachUserPolicy',
  params: {UserName: '', PolicyArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=DetachUserPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=DetachUserPolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=DetachUserPolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=DetachUserPolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=DetachUserPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DetachUserPolicy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'UserName' => '',
  'PolicyArn' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DetachUserPolicy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'UserName' => '',
  'PolicyArn' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=DetachUserPolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=DetachUserPolicy' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?UserName=&PolicyArn=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DetachUserPolicy"

querystring = {"UserName":"","PolicyArn":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DetachUserPolicy"

queryString <- list(
  UserName = "",
  PolicyArn = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=DetachUserPolicy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['UserName'] = ''
  req.params['PolicyArn'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DetachUserPolicy";

    let querystring = [
        ("UserName", ""),
        ("PolicyArn", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=DetachUserPolicy'
http GET '{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=DetachUserPolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=DetachUserPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?UserName=&PolicyArn=&Action=&Version=#Action=DetachUserPolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_EnableMFADevice
{{baseUrl}}/#Action=EnableMFADevice
QUERY PARAMS
UserName
SerialNumber
AuthenticationCode1
AuthenticationCode2
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=EnableMFADevice");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=EnableMFADevice" {:query-params {:UserName ""
                                                                                  :SerialNumber ""
                                                                                  :AuthenticationCode1 ""
                                                                                  :AuthenticationCode2 ""
                                                                                  :Action ""
                                                                                  :Version ""}})
require "http/client"

url = "{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=EnableMFADevice"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=EnableMFADevice"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=EnableMFADevice");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=EnableMFADevice"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=EnableMFADevice")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=EnableMFADevice"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=EnableMFADevice")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=EnableMFADevice")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=EnableMFADevice');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=EnableMFADevice',
  params: {
    UserName: '',
    SerialNumber: '',
    AuthenticationCode1: '',
    AuthenticationCode2: '',
    Action: '',
    Version: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=EnableMFADevice';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=EnableMFADevice',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=EnableMFADevice")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=EnableMFADevice',
  qs: {
    UserName: '',
    SerialNumber: '',
    AuthenticationCode1: '',
    AuthenticationCode2: '',
    Action: '',
    Version: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=EnableMFADevice');

req.query({
  UserName: '',
  SerialNumber: '',
  AuthenticationCode1: '',
  AuthenticationCode2: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=EnableMFADevice',
  params: {
    UserName: '',
    SerialNumber: '',
    AuthenticationCode1: '',
    AuthenticationCode2: '',
    Action: '',
    Version: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=EnableMFADevice';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=EnableMFADevice"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=EnableMFADevice" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=EnableMFADevice",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=EnableMFADevice');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=EnableMFADevice');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'UserName' => '',
  'SerialNumber' => '',
  'AuthenticationCode1' => '',
  'AuthenticationCode2' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=EnableMFADevice');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'UserName' => '',
  'SerialNumber' => '',
  'AuthenticationCode1' => '',
  'AuthenticationCode2' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=EnableMFADevice' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=EnableMFADevice' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=EnableMFADevice"

querystring = {"UserName":"","SerialNumber":"","AuthenticationCode1":"","AuthenticationCode2":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=EnableMFADevice"

queryString <- list(
  UserName = "",
  SerialNumber = "",
  AuthenticationCode1 = "",
  AuthenticationCode2 = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=EnableMFADevice")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['UserName'] = ''
  req.params['SerialNumber'] = ''
  req.params['AuthenticationCode1'] = ''
  req.params['AuthenticationCode2'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=EnableMFADevice";

    let querystring = [
        ("UserName", ""),
        ("SerialNumber", ""),
        ("AuthenticationCode1", ""),
        ("AuthenticationCode2", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=EnableMFADevice'
http GET '{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=EnableMFADevice'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=EnableMFADevice'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=EnableMFADevice")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_GenerateCredentialReport
{{baseUrl}}/#Action=GenerateCredentialReport
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=GenerateCredentialReport" {:query-params {:Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GenerateCredentialReport',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GenerateCredentialReport',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=GenerateCredentialReport');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GenerateCredentialReport',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GenerateCredentialReport');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GenerateCredentialReport');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GenerateCredentialReport"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GenerateCredentialReport"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GenerateCredentialReport";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport'
http GET '{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_GenerateOrganizationsAccessReport
{{baseUrl}}/#Action=GenerateOrganizationsAccessReport
QUERY PARAMS
EntityPath
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?EntityPath=&Action=&Version=#Action=GenerateOrganizationsAccessReport");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=GenerateOrganizationsAccessReport" {:query-params {:EntityPath ""
                                                                                                    :Action ""
                                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?EntityPath=&Action=&Version=#Action=GenerateOrganizationsAccessReport"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?EntityPath=&Action=&Version=#Action=GenerateOrganizationsAccessReport"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?EntityPath=&Action=&Version=#Action=GenerateOrganizationsAccessReport");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?EntityPath=&Action=&Version=#Action=GenerateOrganizationsAccessReport"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?EntityPath=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?EntityPath=&Action=&Version=#Action=GenerateOrganizationsAccessReport")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?EntityPath=&Action=&Version=#Action=GenerateOrganizationsAccessReport"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?EntityPath=&Action=&Version=#Action=GenerateOrganizationsAccessReport")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?EntityPath=&Action=&Version=#Action=GenerateOrganizationsAccessReport")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?EntityPath=&Action=&Version=#Action=GenerateOrganizationsAccessReport');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GenerateOrganizationsAccessReport',
  params: {EntityPath: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?EntityPath=&Action=&Version=#Action=GenerateOrganizationsAccessReport';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?EntityPath=&Action=&Version=#Action=GenerateOrganizationsAccessReport',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?EntityPath=&Action=&Version=#Action=GenerateOrganizationsAccessReport")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?EntityPath=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GenerateOrganizationsAccessReport',
  qs: {EntityPath: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=GenerateOrganizationsAccessReport');

req.query({
  EntityPath: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GenerateOrganizationsAccessReport',
  params: {EntityPath: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?EntityPath=&Action=&Version=#Action=GenerateOrganizationsAccessReport';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?EntityPath=&Action=&Version=#Action=GenerateOrganizationsAccessReport"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?EntityPath=&Action=&Version=#Action=GenerateOrganizationsAccessReport" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?EntityPath=&Action=&Version=#Action=GenerateOrganizationsAccessReport",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?EntityPath=&Action=&Version=#Action=GenerateOrganizationsAccessReport');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GenerateOrganizationsAccessReport');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'EntityPath' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GenerateOrganizationsAccessReport');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'EntityPath' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?EntityPath=&Action=&Version=#Action=GenerateOrganizationsAccessReport' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?EntityPath=&Action=&Version=#Action=GenerateOrganizationsAccessReport' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?EntityPath=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GenerateOrganizationsAccessReport"

querystring = {"EntityPath":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GenerateOrganizationsAccessReport"

queryString <- list(
  EntityPath = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?EntityPath=&Action=&Version=#Action=GenerateOrganizationsAccessReport")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['EntityPath'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GenerateOrganizationsAccessReport";

    let querystring = [
        ("EntityPath", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?EntityPath=&Action=&Version=#Action=GenerateOrganizationsAccessReport'
http GET '{{baseUrl}}/?EntityPath=&Action=&Version=#Action=GenerateOrganizationsAccessReport'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?EntityPath=&Action=&Version=#Action=GenerateOrganizationsAccessReport'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?EntityPath=&Action=&Version=#Action=GenerateOrganizationsAccessReport")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "JobId": "examplea-1234-b567-cde8-90fg123abcd4"
}
GET GET_GenerateServiceLastAccessedDetails
{{baseUrl}}/#Action=GenerateServiceLastAccessedDetails
QUERY PARAMS
Arn
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Arn=&Action=&Version=#Action=GenerateServiceLastAccessedDetails");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=GenerateServiceLastAccessedDetails" {:query-params {:Arn ""
                                                                                                     :Action ""
                                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Arn=&Action=&Version=#Action=GenerateServiceLastAccessedDetails"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?Arn=&Action=&Version=#Action=GenerateServiceLastAccessedDetails"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Arn=&Action=&Version=#Action=GenerateServiceLastAccessedDetails");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Arn=&Action=&Version=#Action=GenerateServiceLastAccessedDetails"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?Arn=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?Arn=&Action=&Version=#Action=GenerateServiceLastAccessedDetails")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Arn=&Action=&Version=#Action=GenerateServiceLastAccessedDetails"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?Arn=&Action=&Version=#Action=GenerateServiceLastAccessedDetails")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Arn=&Action=&Version=#Action=GenerateServiceLastAccessedDetails")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?Arn=&Action=&Version=#Action=GenerateServiceLastAccessedDetails');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GenerateServiceLastAccessedDetails',
  params: {Arn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Arn=&Action=&Version=#Action=GenerateServiceLastAccessedDetails';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?Arn=&Action=&Version=#Action=GenerateServiceLastAccessedDetails',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Arn=&Action=&Version=#Action=GenerateServiceLastAccessedDetails")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Arn=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GenerateServiceLastAccessedDetails',
  qs: {Arn: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=GenerateServiceLastAccessedDetails');

req.query({
  Arn: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GenerateServiceLastAccessedDetails',
  params: {Arn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Arn=&Action=&Version=#Action=GenerateServiceLastAccessedDetails';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?Arn=&Action=&Version=#Action=GenerateServiceLastAccessedDetails"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?Arn=&Action=&Version=#Action=GenerateServiceLastAccessedDetails" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Arn=&Action=&Version=#Action=GenerateServiceLastAccessedDetails",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?Arn=&Action=&Version=#Action=GenerateServiceLastAccessedDetails');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GenerateServiceLastAccessedDetails');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Arn' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GenerateServiceLastAccessedDetails');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Arn' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Arn=&Action=&Version=#Action=GenerateServiceLastAccessedDetails' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Arn=&Action=&Version=#Action=GenerateServiceLastAccessedDetails' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?Arn=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GenerateServiceLastAccessedDetails"

querystring = {"Arn":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GenerateServiceLastAccessedDetails"

queryString <- list(
  Arn = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Arn=&Action=&Version=#Action=GenerateServiceLastAccessedDetails")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['Arn'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GenerateServiceLastAccessedDetails";

    let querystring = [
        ("Arn", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?Arn=&Action=&Version=#Action=GenerateServiceLastAccessedDetails'
http GET '{{baseUrl}}/?Arn=&Action=&Version=#Action=GenerateServiceLastAccessedDetails'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Arn=&Action=&Version=#Action=GenerateServiceLastAccessedDetails'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Arn=&Action=&Version=#Action=GenerateServiceLastAccessedDetails")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "JobId": "examplef-1305-c245-eba4-71fe298bcda7"
}
GET GET_GetAccessKeyLastUsed
{{baseUrl}}/#Action=GetAccessKeyLastUsed
QUERY PARAMS
AccessKeyId
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=GetAccessKeyLastUsed");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=GetAccessKeyLastUsed" {:query-params {:AccessKeyId ""
                                                                                       :Action ""
                                                                                       :Version ""}})
require "http/client"

url = "{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=GetAccessKeyLastUsed"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=GetAccessKeyLastUsed"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=GetAccessKeyLastUsed");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=GetAccessKeyLastUsed"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?AccessKeyId=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=GetAccessKeyLastUsed")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=GetAccessKeyLastUsed"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=GetAccessKeyLastUsed")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=GetAccessKeyLastUsed")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=GetAccessKeyLastUsed');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetAccessKeyLastUsed',
  params: {AccessKeyId: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=GetAccessKeyLastUsed';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=GetAccessKeyLastUsed',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=GetAccessKeyLastUsed")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?AccessKeyId=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetAccessKeyLastUsed',
  qs: {AccessKeyId: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=GetAccessKeyLastUsed');

req.query({
  AccessKeyId: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetAccessKeyLastUsed',
  params: {AccessKeyId: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=GetAccessKeyLastUsed';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=GetAccessKeyLastUsed"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=GetAccessKeyLastUsed" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=GetAccessKeyLastUsed",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=GetAccessKeyLastUsed');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetAccessKeyLastUsed');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'AccessKeyId' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetAccessKeyLastUsed');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'AccessKeyId' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=GetAccessKeyLastUsed' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=GetAccessKeyLastUsed' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?AccessKeyId=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetAccessKeyLastUsed"

querystring = {"AccessKeyId":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetAccessKeyLastUsed"

queryString <- list(
  AccessKeyId = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=GetAccessKeyLastUsed")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['AccessKeyId'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetAccessKeyLastUsed";

    let querystring = [
        ("AccessKeyId", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=GetAccessKeyLastUsed'
http GET '{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=GetAccessKeyLastUsed'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=GetAccessKeyLastUsed'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?AccessKeyId=&Action=&Version=#Action=GetAccessKeyLastUsed")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_GetAccountAuthorizationDetails
{{baseUrl}}/#Action=GetAccountAuthorizationDetails
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=GetAccountAuthorizationDetails" {:query-params {:Action ""
                                                                                                 :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetAccountAuthorizationDetails',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetAccountAuthorizationDetails',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=GetAccountAuthorizationDetails');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetAccountAuthorizationDetails',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetAccountAuthorizationDetails');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetAccountAuthorizationDetails');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetAccountAuthorizationDetails"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetAccountAuthorizationDetails"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetAccountAuthorizationDetails";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails'
http GET '{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_GetAccountPasswordPolicy
{{baseUrl}}/#Action=GetAccountPasswordPolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=GetAccountPasswordPolicy" {:query-params {:Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetAccountPasswordPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetAccountPasswordPolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=GetAccountPasswordPolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetAccountPasswordPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetAccountPasswordPolicy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetAccountPasswordPolicy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetAccountPasswordPolicy"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetAccountPasswordPolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetAccountPasswordPolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy'
http GET '{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "PasswordPolicy": {
    "AllowUsersToChangePassword": false,
    "ExpirePasswords": false,
    "HardExpiry": false,
    "MaxPasswordAge": 90,
    "MinimumPasswordLength": 8,
    "PasswordReusePrevention": 12,
    "RequireLowercaseCharacters": false,
    "RequireNumbers": true,
    "RequireSymbols": true,
    "RequireUppercaseCharacters": false
  }
}
GET GET_GetAccountSummary
{{baseUrl}}/#Action=GetAccountSummary
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=GetAccountSummary" {:query-params {:Action ""
                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetAccountSummary',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetAccountSummary',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=GetAccountSummary');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetAccountSummary',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetAccountSummary');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetAccountSummary');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetAccountSummary"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetAccountSummary"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetAccountSummary";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary'
http GET '{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "SummaryMap": {
    "AccessKeysPerUserQuota": 2,
    "AccountAccessKeysPresent": 1,
    "AccountMFAEnabled": 0,
    "AccountSigningCertificatesPresent": 0,
    "AttachedPoliciesPerGroupQuota": 10,
    "AttachedPoliciesPerRoleQuota": 10,
    "AttachedPoliciesPerUserQuota": 10,
    "GlobalEndpointTokenVersion": 2,
    "GroupPolicySizeQuota": 5120,
    "Groups": 15,
    "GroupsPerUserQuota": 10,
    "GroupsQuota": 100,
    "MFADevices": 6,
    "MFADevicesInUse": 3,
    "Policies": 8,
    "PoliciesQuota": 1000,
    "PolicySizeQuota": 5120,
    "PolicyVersionsInUse": 22,
    "PolicyVersionsInUseQuota": 10000,
    "ServerCertificates": 1,
    "ServerCertificatesQuota": 20,
    "SigningCertificatesPerUserQuota": 2,
    "UserPolicySizeQuota": 2048,
    "Users": 27,
    "UsersQuota": 5000,
    "VersionsPerPolicyQuota": 5
  }
}
GET GET_GetContextKeysForCustomPolicy
{{baseUrl}}/#Action=GetContextKeysForCustomPolicy
QUERY PARAMS
PolicyInputList
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?PolicyInputList=&Action=&Version=#Action=GetContextKeysForCustomPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=GetContextKeysForCustomPolicy" {:query-params {:PolicyInputList ""
                                                                                                :Action ""
                                                                                                :Version ""}})
require "http/client"

url = "{{baseUrl}}/?PolicyInputList=&Action=&Version=#Action=GetContextKeysForCustomPolicy"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?PolicyInputList=&Action=&Version=#Action=GetContextKeysForCustomPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?PolicyInputList=&Action=&Version=#Action=GetContextKeysForCustomPolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?PolicyInputList=&Action=&Version=#Action=GetContextKeysForCustomPolicy"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?PolicyInputList=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?PolicyInputList=&Action=&Version=#Action=GetContextKeysForCustomPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?PolicyInputList=&Action=&Version=#Action=GetContextKeysForCustomPolicy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?PolicyInputList=&Action=&Version=#Action=GetContextKeysForCustomPolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?PolicyInputList=&Action=&Version=#Action=GetContextKeysForCustomPolicy")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?PolicyInputList=&Action=&Version=#Action=GetContextKeysForCustomPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetContextKeysForCustomPolicy',
  params: {PolicyInputList: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?PolicyInputList=&Action=&Version=#Action=GetContextKeysForCustomPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?PolicyInputList=&Action=&Version=#Action=GetContextKeysForCustomPolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?PolicyInputList=&Action=&Version=#Action=GetContextKeysForCustomPolicy")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?PolicyInputList=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetContextKeysForCustomPolicy',
  qs: {PolicyInputList: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=GetContextKeysForCustomPolicy');

req.query({
  PolicyInputList: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetContextKeysForCustomPolicy',
  params: {PolicyInputList: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?PolicyInputList=&Action=&Version=#Action=GetContextKeysForCustomPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?PolicyInputList=&Action=&Version=#Action=GetContextKeysForCustomPolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?PolicyInputList=&Action=&Version=#Action=GetContextKeysForCustomPolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?PolicyInputList=&Action=&Version=#Action=GetContextKeysForCustomPolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?PolicyInputList=&Action=&Version=#Action=GetContextKeysForCustomPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetContextKeysForCustomPolicy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'PolicyInputList' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetContextKeysForCustomPolicy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'PolicyInputList' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?PolicyInputList=&Action=&Version=#Action=GetContextKeysForCustomPolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?PolicyInputList=&Action=&Version=#Action=GetContextKeysForCustomPolicy' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?PolicyInputList=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetContextKeysForCustomPolicy"

querystring = {"PolicyInputList":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetContextKeysForCustomPolicy"

queryString <- list(
  PolicyInputList = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?PolicyInputList=&Action=&Version=#Action=GetContextKeysForCustomPolicy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['PolicyInputList'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetContextKeysForCustomPolicy";

    let querystring = [
        ("PolicyInputList", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?PolicyInputList=&Action=&Version=#Action=GetContextKeysForCustomPolicy'
http GET '{{baseUrl}}/?PolicyInputList=&Action=&Version=#Action=GetContextKeysForCustomPolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?PolicyInputList=&Action=&Version=#Action=GetContextKeysForCustomPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?PolicyInputList=&Action=&Version=#Action=GetContextKeysForCustomPolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_GetContextKeysForPrincipalPolicy
{{baseUrl}}/#Action=GetContextKeysForPrincipalPolicy
QUERY PARAMS
PolicySourceArn
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?PolicySourceArn=&Action=&Version=#Action=GetContextKeysForPrincipalPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=GetContextKeysForPrincipalPolicy" {:query-params {:PolicySourceArn ""
                                                                                                   :Action ""
                                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?PolicySourceArn=&Action=&Version=#Action=GetContextKeysForPrincipalPolicy"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?PolicySourceArn=&Action=&Version=#Action=GetContextKeysForPrincipalPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?PolicySourceArn=&Action=&Version=#Action=GetContextKeysForPrincipalPolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?PolicySourceArn=&Action=&Version=#Action=GetContextKeysForPrincipalPolicy"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?PolicySourceArn=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?PolicySourceArn=&Action=&Version=#Action=GetContextKeysForPrincipalPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?PolicySourceArn=&Action=&Version=#Action=GetContextKeysForPrincipalPolicy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?PolicySourceArn=&Action=&Version=#Action=GetContextKeysForPrincipalPolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?PolicySourceArn=&Action=&Version=#Action=GetContextKeysForPrincipalPolicy")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?PolicySourceArn=&Action=&Version=#Action=GetContextKeysForPrincipalPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetContextKeysForPrincipalPolicy',
  params: {PolicySourceArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?PolicySourceArn=&Action=&Version=#Action=GetContextKeysForPrincipalPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?PolicySourceArn=&Action=&Version=#Action=GetContextKeysForPrincipalPolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?PolicySourceArn=&Action=&Version=#Action=GetContextKeysForPrincipalPolicy")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?PolicySourceArn=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetContextKeysForPrincipalPolicy',
  qs: {PolicySourceArn: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=GetContextKeysForPrincipalPolicy');

req.query({
  PolicySourceArn: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetContextKeysForPrincipalPolicy',
  params: {PolicySourceArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?PolicySourceArn=&Action=&Version=#Action=GetContextKeysForPrincipalPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?PolicySourceArn=&Action=&Version=#Action=GetContextKeysForPrincipalPolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?PolicySourceArn=&Action=&Version=#Action=GetContextKeysForPrincipalPolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?PolicySourceArn=&Action=&Version=#Action=GetContextKeysForPrincipalPolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?PolicySourceArn=&Action=&Version=#Action=GetContextKeysForPrincipalPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetContextKeysForPrincipalPolicy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'PolicySourceArn' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetContextKeysForPrincipalPolicy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'PolicySourceArn' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?PolicySourceArn=&Action=&Version=#Action=GetContextKeysForPrincipalPolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?PolicySourceArn=&Action=&Version=#Action=GetContextKeysForPrincipalPolicy' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?PolicySourceArn=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetContextKeysForPrincipalPolicy"

querystring = {"PolicySourceArn":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetContextKeysForPrincipalPolicy"

queryString <- list(
  PolicySourceArn = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?PolicySourceArn=&Action=&Version=#Action=GetContextKeysForPrincipalPolicy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['PolicySourceArn'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetContextKeysForPrincipalPolicy";

    let querystring = [
        ("PolicySourceArn", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?PolicySourceArn=&Action=&Version=#Action=GetContextKeysForPrincipalPolicy'
http GET '{{baseUrl}}/?PolicySourceArn=&Action=&Version=#Action=GetContextKeysForPrincipalPolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?PolicySourceArn=&Action=&Version=#Action=GetContextKeysForPrincipalPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?PolicySourceArn=&Action=&Version=#Action=GetContextKeysForPrincipalPolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_GetCredentialReport
{{baseUrl}}/#Action=GetCredentialReport
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=GetCredentialReport" {:query-params {:Action ""
                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetCredentialReport',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetCredentialReport',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=GetCredentialReport');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetCredentialReport',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetCredentialReport');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetCredentialReport');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetCredentialReport"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetCredentialReport"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetCredentialReport";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport'
http GET '{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_GetGroup
{{baseUrl}}/#Action=GetGroup
QUERY PARAMS
GroupName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?GroupName=&Action=&Version=#Action=GetGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=GetGroup" {:query-params {:GroupName ""
                                                                           :Action ""
                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?GroupName=&Action=&Version=#Action=GetGroup"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?GroupName=&Action=&Version=#Action=GetGroup"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?GroupName=&Action=&Version=#Action=GetGroup");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?GroupName=&Action=&Version=#Action=GetGroup"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?GroupName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?GroupName=&Action=&Version=#Action=GetGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?GroupName=&Action=&Version=#Action=GetGroup"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?GroupName=&Action=&Version=#Action=GetGroup")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?GroupName=&Action=&Version=#Action=GetGroup")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?GroupName=&Action=&Version=#Action=GetGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetGroup',
  params: {GroupName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?GroupName=&Action=&Version=#Action=GetGroup';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?GroupName=&Action=&Version=#Action=GetGroup',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?GroupName=&Action=&Version=#Action=GetGroup")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?GroupName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetGroup',
  qs: {GroupName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=GetGroup');

req.query({
  GroupName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetGroup',
  params: {GroupName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?GroupName=&Action=&Version=#Action=GetGroup';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?GroupName=&Action=&Version=#Action=GetGroup"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?GroupName=&Action=&Version=#Action=GetGroup" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?GroupName=&Action=&Version=#Action=GetGroup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?GroupName=&Action=&Version=#Action=GetGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetGroup');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'GroupName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetGroup');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'GroupName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?GroupName=&Action=&Version=#Action=GetGroup' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?GroupName=&Action=&Version=#Action=GetGroup' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?GroupName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetGroup"

querystring = {"GroupName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetGroup"

queryString <- list(
  GroupName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?GroupName=&Action=&Version=#Action=GetGroup")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['GroupName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetGroup";

    let querystring = [
        ("GroupName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?GroupName=&Action=&Version=#Action=GetGroup'
http GET '{{baseUrl}}/?GroupName=&Action=&Version=#Action=GetGroup'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?GroupName=&Action=&Version=#Action=GetGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?GroupName=&Action=&Version=#Action=GetGroup")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_GetGroupPolicy
{{baseUrl}}/#Action=GetGroupPolicy
QUERY PARAMS
GroupName
PolicyName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=GetGroupPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=GetGroupPolicy" {:query-params {:GroupName ""
                                                                                 :PolicyName ""
                                                                                 :Action ""
                                                                                 :Version ""}})
require "http/client"

url = "{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=GetGroupPolicy"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=GetGroupPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=GetGroupPolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=GetGroupPolicy"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?GroupName=&PolicyName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=GetGroupPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=GetGroupPolicy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=GetGroupPolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=GetGroupPolicy")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=GetGroupPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetGroupPolicy',
  params: {GroupName: '', PolicyName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=GetGroupPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=GetGroupPolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=GetGroupPolicy")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?GroupName=&PolicyName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetGroupPolicy',
  qs: {GroupName: '', PolicyName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=GetGroupPolicy');

req.query({
  GroupName: '',
  PolicyName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetGroupPolicy',
  params: {GroupName: '', PolicyName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=GetGroupPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=GetGroupPolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=GetGroupPolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=GetGroupPolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=GetGroupPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetGroupPolicy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'GroupName' => '',
  'PolicyName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetGroupPolicy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'GroupName' => '',
  'PolicyName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=GetGroupPolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=GetGroupPolicy' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?GroupName=&PolicyName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetGroupPolicy"

querystring = {"GroupName":"","PolicyName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetGroupPolicy"

queryString <- list(
  GroupName = "",
  PolicyName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=GetGroupPolicy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['GroupName'] = ''
  req.params['PolicyName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetGroupPolicy";

    let querystring = [
        ("GroupName", ""),
        ("PolicyName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=GetGroupPolicy'
http GET '{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=GetGroupPolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=GetGroupPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?GroupName=&PolicyName=&Action=&Version=#Action=GetGroupPolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_GetInstanceProfile
{{baseUrl}}/#Action=GetInstanceProfile
QUERY PARAMS
InstanceProfileName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=GetInstanceProfile");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=GetInstanceProfile" {:query-params {:InstanceProfileName ""
                                                                                     :Action ""
                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=GetInstanceProfile"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=GetInstanceProfile"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=GetInstanceProfile");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=GetInstanceProfile"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?InstanceProfileName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=GetInstanceProfile")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=GetInstanceProfile"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=GetInstanceProfile")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=GetInstanceProfile")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=GetInstanceProfile');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetInstanceProfile',
  params: {InstanceProfileName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=GetInstanceProfile';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=GetInstanceProfile',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=GetInstanceProfile")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?InstanceProfileName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetInstanceProfile',
  qs: {InstanceProfileName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=GetInstanceProfile');

req.query({
  InstanceProfileName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetInstanceProfile',
  params: {InstanceProfileName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=GetInstanceProfile';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=GetInstanceProfile"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=GetInstanceProfile" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=GetInstanceProfile",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=GetInstanceProfile');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetInstanceProfile');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'InstanceProfileName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetInstanceProfile');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'InstanceProfileName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=GetInstanceProfile' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=GetInstanceProfile' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?InstanceProfileName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetInstanceProfile"

querystring = {"InstanceProfileName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetInstanceProfile"

queryString <- list(
  InstanceProfileName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=GetInstanceProfile")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['InstanceProfileName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetInstanceProfile";

    let querystring = [
        ("InstanceProfileName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=GetInstanceProfile'
http GET '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=GetInstanceProfile'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=GetInstanceProfile'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=GetInstanceProfile")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "InstanceProfile": {
    "Arn": "arn:aws:iam::336924118301:instance-profile/ExampleInstanceProfile",
    "CreateDate": "2013-06-12T23:52:02Z",
    "InstanceProfileId": "AID2MAB8DPLSRHEXAMPLE",
    "InstanceProfileName": "ExampleInstanceProfile",
    "Path": "/",
    "Roles": [
      {
        "Arn": "arn:aws:iam::336924118301:role/Test-Role",
        "AssumeRolePolicyDocument": "",
        "CreateDate": "2013-01-09T06:33:26Z",
        "Path": "/",
        "RoleId": "AIDGPMS9RO4H3FEXAMPLE",
        "RoleName": "Test-Role"
      }
    ]
  }
}
GET GET_GetLoginProfile
{{baseUrl}}/#Action=GetLoginProfile
QUERY PARAMS
UserName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?UserName=&Action=&Version=#Action=GetLoginProfile");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=GetLoginProfile" {:query-params {:UserName ""
                                                                                  :Action ""
                                                                                  :Version ""}})
require "http/client"

url = "{{baseUrl}}/?UserName=&Action=&Version=#Action=GetLoginProfile"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?UserName=&Action=&Version=#Action=GetLoginProfile"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?UserName=&Action=&Version=#Action=GetLoginProfile");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?UserName=&Action=&Version=#Action=GetLoginProfile"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?UserName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?UserName=&Action=&Version=#Action=GetLoginProfile")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?UserName=&Action=&Version=#Action=GetLoginProfile"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?UserName=&Action=&Version=#Action=GetLoginProfile")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?UserName=&Action=&Version=#Action=GetLoginProfile")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?UserName=&Action=&Version=#Action=GetLoginProfile');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetLoginProfile',
  params: {UserName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?UserName=&Action=&Version=#Action=GetLoginProfile';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?UserName=&Action=&Version=#Action=GetLoginProfile',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?UserName=&Action=&Version=#Action=GetLoginProfile")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?UserName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetLoginProfile',
  qs: {UserName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=GetLoginProfile');

req.query({
  UserName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetLoginProfile',
  params: {UserName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?UserName=&Action=&Version=#Action=GetLoginProfile';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?UserName=&Action=&Version=#Action=GetLoginProfile"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?UserName=&Action=&Version=#Action=GetLoginProfile" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?UserName=&Action=&Version=#Action=GetLoginProfile",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?UserName=&Action=&Version=#Action=GetLoginProfile');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetLoginProfile');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'UserName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetLoginProfile');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'UserName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?UserName=&Action=&Version=#Action=GetLoginProfile' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?UserName=&Action=&Version=#Action=GetLoginProfile' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?UserName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetLoginProfile"

querystring = {"UserName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetLoginProfile"

queryString <- list(
  UserName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?UserName=&Action=&Version=#Action=GetLoginProfile")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['UserName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetLoginProfile";

    let querystring = [
        ("UserName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?UserName=&Action=&Version=#Action=GetLoginProfile'
http GET '{{baseUrl}}/?UserName=&Action=&Version=#Action=GetLoginProfile'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?UserName=&Action=&Version=#Action=GetLoginProfile'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?UserName=&Action=&Version=#Action=GetLoginProfile")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "LoginProfile": {
    "CreateDate": "2012-09-21T23:03:39Z",
    "UserName": "Anika"
  }
}
GET GET_GetOpenIDConnectProvider
{{baseUrl}}/#Action=GetOpenIDConnectProvider
QUERY PARAMS
OpenIDConnectProviderArn
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=GetOpenIDConnectProvider");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=GetOpenIDConnectProvider" {:query-params {:OpenIDConnectProviderArn ""
                                                                                           :Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=GetOpenIDConnectProvider"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=GetOpenIDConnectProvider"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=GetOpenIDConnectProvider");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=GetOpenIDConnectProvider"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?OpenIDConnectProviderArn=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=GetOpenIDConnectProvider")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=GetOpenIDConnectProvider"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=GetOpenIDConnectProvider")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=GetOpenIDConnectProvider")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=GetOpenIDConnectProvider');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetOpenIDConnectProvider',
  params: {OpenIDConnectProviderArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=GetOpenIDConnectProvider';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=GetOpenIDConnectProvider',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=GetOpenIDConnectProvider")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?OpenIDConnectProviderArn=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetOpenIDConnectProvider',
  qs: {OpenIDConnectProviderArn: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=GetOpenIDConnectProvider');

req.query({
  OpenIDConnectProviderArn: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetOpenIDConnectProvider',
  params: {OpenIDConnectProviderArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=GetOpenIDConnectProvider';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=GetOpenIDConnectProvider"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=GetOpenIDConnectProvider" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=GetOpenIDConnectProvider",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=GetOpenIDConnectProvider');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetOpenIDConnectProvider');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'OpenIDConnectProviderArn' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetOpenIDConnectProvider');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'OpenIDConnectProviderArn' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=GetOpenIDConnectProvider' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=GetOpenIDConnectProvider' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?OpenIDConnectProviderArn=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetOpenIDConnectProvider"

querystring = {"OpenIDConnectProviderArn":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetOpenIDConnectProvider"

queryString <- list(
  OpenIDConnectProviderArn = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=GetOpenIDConnectProvider")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['OpenIDConnectProviderArn'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetOpenIDConnectProvider";

    let querystring = [
        ("OpenIDConnectProviderArn", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=GetOpenIDConnectProvider'
http GET '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=GetOpenIDConnectProvider'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=GetOpenIDConnectProvider'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=GetOpenIDConnectProvider")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_GetOrganizationsAccessReport
{{baseUrl}}/#Action=GetOrganizationsAccessReport
QUERY PARAMS
JobId
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?JobId=&Action=&Version=#Action=GetOrganizationsAccessReport");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=GetOrganizationsAccessReport" {:query-params {:JobId ""
                                                                                               :Action ""
                                                                                               :Version ""}})
require "http/client"

url = "{{baseUrl}}/?JobId=&Action=&Version=#Action=GetOrganizationsAccessReport"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?JobId=&Action=&Version=#Action=GetOrganizationsAccessReport"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?JobId=&Action=&Version=#Action=GetOrganizationsAccessReport");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?JobId=&Action=&Version=#Action=GetOrganizationsAccessReport"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?JobId=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?JobId=&Action=&Version=#Action=GetOrganizationsAccessReport")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?JobId=&Action=&Version=#Action=GetOrganizationsAccessReport"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?JobId=&Action=&Version=#Action=GetOrganizationsAccessReport")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?JobId=&Action=&Version=#Action=GetOrganizationsAccessReport")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?JobId=&Action=&Version=#Action=GetOrganizationsAccessReport');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetOrganizationsAccessReport',
  params: {JobId: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?JobId=&Action=&Version=#Action=GetOrganizationsAccessReport';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?JobId=&Action=&Version=#Action=GetOrganizationsAccessReport',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?JobId=&Action=&Version=#Action=GetOrganizationsAccessReport")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?JobId=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetOrganizationsAccessReport',
  qs: {JobId: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=GetOrganizationsAccessReport');

req.query({
  JobId: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetOrganizationsAccessReport',
  params: {JobId: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?JobId=&Action=&Version=#Action=GetOrganizationsAccessReport';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?JobId=&Action=&Version=#Action=GetOrganizationsAccessReport"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?JobId=&Action=&Version=#Action=GetOrganizationsAccessReport" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?JobId=&Action=&Version=#Action=GetOrganizationsAccessReport",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?JobId=&Action=&Version=#Action=GetOrganizationsAccessReport');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetOrganizationsAccessReport');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'JobId' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetOrganizationsAccessReport');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'JobId' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?JobId=&Action=&Version=#Action=GetOrganizationsAccessReport' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?JobId=&Action=&Version=#Action=GetOrganizationsAccessReport' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?JobId=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetOrganizationsAccessReport"

querystring = {"JobId":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetOrganizationsAccessReport"

queryString <- list(
  JobId = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?JobId=&Action=&Version=#Action=GetOrganizationsAccessReport")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['JobId'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetOrganizationsAccessReport";

    let querystring = [
        ("JobId", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?JobId=&Action=&Version=#Action=GetOrganizationsAccessReport'
http GET '{{baseUrl}}/?JobId=&Action=&Version=#Action=GetOrganizationsAccessReport'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?JobId=&Action=&Version=#Action=GetOrganizationsAccessReport'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?JobId=&Action=&Version=#Action=GetOrganizationsAccessReport")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "AccessDetails": [
    {
      "EntityPath": "o-a1b2c3d4e5/r-f6g7h8i9j0example/ou-1a2b3c-k9l8m7n6o5example/111122223333",
      "LastAuthenticatedTime": "2019-05-25T16:29:52Z",
      "Region": "us-east-1",
      "ServiceName": "Amazon DynamoDB",
      "ServiceNamespace": "dynamodb",
      "TotalAuthenticatedEntities": 2
    },
    {
      "EntityPath": "o-a1b2c3d4e5/r-f6g7h8i9j0example/ou-1a2b3c-k9l8m7n6o5example/123456789012",
      "LastAuthenticatedTime": "2019-06-15T13:12:06Z",
      "Region": "us-east-1",
      "ServiceName": "AWS Identity and Access Management",
      "ServiceNamespace": "iam",
      "TotalAuthenticatedEntities": 4
    },
    {
      "ServiceName": "Amazon Simple Storage Service",
      "ServiceNamespace": "s3",
      "TotalAuthenticatedEntities": 0
    }
  ],
  "IsTruncated": false,
  "JobCompletionDate": "2019-06-18T19:47:35.241Z",
  "JobCreationDate": "2019-06-18T19:47:31.466Z",
  "JobStatus": "COMPLETED",
  "NumberOfServicesAccessible": 3,
  "NumberOfServicesNotAccessed": 1
}
GET GET_GetPolicy
{{baseUrl}}/#Action=GetPolicy
QUERY PARAMS
PolicyArn
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=GetPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=GetPolicy" {:query-params {:PolicyArn ""
                                                                            :Action ""
                                                                            :Version ""}})
require "http/client"

url = "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=GetPolicy"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=GetPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=GetPolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=GetPolicy"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?PolicyArn=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=GetPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=GetPolicy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=GetPolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=GetPolicy")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=GetPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetPolicy',
  params: {PolicyArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=GetPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=GetPolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=GetPolicy")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?PolicyArn=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetPolicy',
  qs: {PolicyArn: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=GetPolicy');

req.query({
  PolicyArn: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetPolicy',
  params: {PolicyArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=GetPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=GetPolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=GetPolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=GetPolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=GetPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetPolicy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'PolicyArn' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetPolicy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'PolicyArn' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=GetPolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=GetPolicy' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?PolicyArn=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetPolicy"

querystring = {"PolicyArn":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetPolicy"

queryString <- list(
  PolicyArn = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=GetPolicy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['PolicyArn'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetPolicy";

    let querystring = [
        ("PolicyArn", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=GetPolicy'
http GET '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=GetPolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=GetPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=GetPolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_GetPolicyVersion
{{baseUrl}}/#Action=GetPolicyVersion
QUERY PARAMS
PolicyArn
VersionId
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=GetPolicyVersion");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=GetPolicyVersion" {:query-params {:PolicyArn ""
                                                                                   :VersionId ""
                                                                                   :Action ""
                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=GetPolicyVersion"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=GetPolicyVersion"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=GetPolicyVersion");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=GetPolicyVersion"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?PolicyArn=&VersionId=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=GetPolicyVersion")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=GetPolicyVersion"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=GetPolicyVersion")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=GetPolicyVersion")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=GetPolicyVersion');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetPolicyVersion',
  params: {PolicyArn: '', VersionId: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=GetPolicyVersion';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=GetPolicyVersion',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=GetPolicyVersion")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?PolicyArn=&VersionId=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetPolicyVersion',
  qs: {PolicyArn: '', VersionId: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=GetPolicyVersion');

req.query({
  PolicyArn: '',
  VersionId: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetPolicyVersion',
  params: {PolicyArn: '', VersionId: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=GetPolicyVersion';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=GetPolicyVersion"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=GetPolicyVersion" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=GetPolicyVersion",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=GetPolicyVersion');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetPolicyVersion');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'PolicyArn' => '',
  'VersionId' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetPolicyVersion');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'PolicyArn' => '',
  'VersionId' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=GetPolicyVersion' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=GetPolicyVersion' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?PolicyArn=&VersionId=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetPolicyVersion"

querystring = {"PolicyArn":"","VersionId":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetPolicyVersion"

queryString <- list(
  PolicyArn = "",
  VersionId = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=GetPolicyVersion")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['PolicyArn'] = ''
  req.params['VersionId'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetPolicyVersion";

    let querystring = [
        ("PolicyArn", ""),
        ("VersionId", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=GetPolicyVersion'
http GET '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=GetPolicyVersion'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=GetPolicyVersion'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=GetPolicyVersion")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_GetRole
{{baseUrl}}/#Action=GetRole
QUERY PARAMS
RoleName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?RoleName=&Action=&Version=#Action=GetRole");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=GetRole" {:query-params {:RoleName ""
                                                                          :Action ""
                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?RoleName=&Action=&Version=#Action=GetRole"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?RoleName=&Action=&Version=#Action=GetRole"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?RoleName=&Action=&Version=#Action=GetRole");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?RoleName=&Action=&Version=#Action=GetRole"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?RoleName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?RoleName=&Action=&Version=#Action=GetRole")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?RoleName=&Action=&Version=#Action=GetRole"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?RoleName=&Action=&Version=#Action=GetRole")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?RoleName=&Action=&Version=#Action=GetRole")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?RoleName=&Action=&Version=#Action=GetRole');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetRole',
  params: {RoleName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?RoleName=&Action=&Version=#Action=GetRole';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?RoleName=&Action=&Version=#Action=GetRole',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?RoleName=&Action=&Version=#Action=GetRole")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?RoleName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetRole',
  qs: {RoleName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=GetRole');

req.query({
  RoleName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetRole',
  params: {RoleName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?RoleName=&Action=&Version=#Action=GetRole';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?RoleName=&Action=&Version=#Action=GetRole"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?RoleName=&Action=&Version=#Action=GetRole" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?RoleName=&Action=&Version=#Action=GetRole",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?RoleName=&Action=&Version=#Action=GetRole');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetRole');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'RoleName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetRole');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'RoleName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?RoleName=&Action=&Version=#Action=GetRole' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?RoleName=&Action=&Version=#Action=GetRole' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?RoleName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetRole"

querystring = {"RoleName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetRole"

queryString <- list(
  RoleName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?RoleName=&Action=&Version=#Action=GetRole")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['RoleName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetRole";

    let querystring = [
        ("RoleName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?RoleName=&Action=&Version=#Action=GetRole'
http GET '{{baseUrl}}/?RoleName=&Action=&Version=#Action=GetRole'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?RoleName=&Action=&Version=#Action=GetRole'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?RoleName=&Action=&Version=#Action=GetRole")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "Role": {
    "Arn": "arn:aws:iam::123456789012:role/Test-Role",
    "AssumeRolePolicyDocument": "",
    "CreateDate": "2013-04-18T05:01:58Z",
    "MaxSessionDuration": 3600,
    "Path": "/",
    "RoleId": "AROADBQP57FF2AEXAMPLE",
    "RoleLastUsed": {
      "LastUsedDate": "2019-11-18T05:01:58Z",
      "Region": "us-east-1"
    },
    "RoleName": "Test-Role"
  }
}
GET GET_GetRolePolicy
{{baseUrl}}/#Action=GetRolePolicy
QUERY PARAMS
RoleName
PolicyName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=GetRolePolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=GetRolePolicy" {:query-params {:RoleName ""
                                                                                :PolicyName ""
                                                                                :Action ""
                                                                                :Version ""}})
require "http/client"

url = "{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=GetRolePolicy"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=GetRolePolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=GetRolePolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=GetRolePolicy"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?RoleName=&PolicyName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=GetRolePolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=GetRolePolicy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=GetRolePolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=GetRolePolicy")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=GetRolePolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetRolePolicy',
  params: {RoleName: '', PolicyName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=GetRolePolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=GetRolePolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=GetRolePolicy")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?RoleName=&PolicyName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetRolePolicy',
  qs: {RoleName: '', PolicyName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=GetRolePolicy');

req.query({
  RoleName: '',
  PolicyName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetRolePolicy',
  params: {RoleName: '', PolicyName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=GetRolePolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=GetRolePolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=GetRolePolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=GetRolePolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=GetRolePolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetRolePolicy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'RoleName' => '',
  'PolicyName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetRolePolicy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'RoleName' => '',
  'PolicyName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=GetRolePolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=GetRolePolicy' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?RoleName=&PolicyName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetRolePolicy"

querystring = {"RoleName":"","PolicyName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetRolePolicy"

queryString <- list(
  RoleName = "",
  PolicyName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=GetRolePolicy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['RoleName'] = ''
  req.params['PolicyName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetRolePolicy";

    let querystring = [
        ("RoleName", ""),
        ("PolicyName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=GetRolePolicy'
http GET '{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=GetRolePolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=GetRolePolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?RoleName=&PolicyName=&Action=&Version=#Action=GetRolePolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_GetSAMLProvider
{{baseUrl}}/#Action=GetSAMLProvider
QUERY PARAMS
SAMLProviderArn
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=GetSAMLProvider");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=GetSAMLProvider" {:query-params {:SAMLProviderArn ""
                                                                                  :Action ""
                                                                                  :Version ""}})
require "http/client"

url = "{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=GetSAMLProvider"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=GetSAMLProvider"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=GetSAMLProvider");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=GetSAMLProvider"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?SAMLProviderArn=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=GetSAMLProvider")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=GetSAMLProvider"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=GetSAMLProvider")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=GetSAMLProvider")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=GetSAMLProvider');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetSAMLProvider',
  params: {SAMLProviderArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=GetSAMLProvider';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=GetSAMLProvider',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=GetSAMLProvider")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?SAMLProviderArn=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetSAMLProvider',
  qs: {SAMLProviderArn: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=GetSAMLProvider');

req.query({
  SAMLProviderArn: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetSAMLProvider',
  params: {SAMLProviderArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=GetSAMLProvider';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=GetSAMLProvider"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=GetSAMLProvider" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=GetSAMLProvider",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=GetSAMLProvider');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetSAMLProvider');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'SAMLProviderArn' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetSAMLProvider');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'SAMLProviderArn' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=GetSAMLProvider' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=GetSAMLProvider' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?SAMLProviderArn=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetSAMLProvider"

querystring = {"SAMLProviderArn":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetSAMLProvider"

queryString <- list(
  SAMLProviderArn = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=GetSAMLProvider")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['SAMLProviderArn'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetSAMLProvider";

    let querystring = [
        ("SAMLProviderArn", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=GetSAMLProvider'
http GET '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=GetSAMLProvider'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=GetSAMLProvider'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=GetSAMLProvider")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_GetSSHPublicKey
{{baseUrl}}/#Action=GetSSHPublicKey
QUERY PARAMS
UserName
SSHPublicKeyId
Encoding
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?UserName=&SSHPublicKeyId=&Encoding=&Action=&Version=#Action=GetSSHPublicKey");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=GetSSHPublicKey" {:query-params {:UserName ""
                                                                                  :SSHPublicKeyId ""
                                                                                  :Encoding ""
                                                                                  :Action ""
                                                                                  :Version ""}})
require "http/client"

url = "{{baseUrl}}/?UserName=&SSHPublicKeyId=&Encoding=&Action=&Version=#Action=GetSSHPublicKey"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?UserName=&SSHPublicKeyId=&Encoding=&Action=&Version=#Action=GetSSHPublicKey"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?UserName=&SSHPublicKeyId=&Encoding=&Action=&Version=#Action=GetSSHPublicKey");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?UserName=&SSHPublicKeyId=&Encoding=&Action=&Version=#Action=GetSSHPublicKey"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?UserName=&SSHPublicKeyId=&Encoding=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?UserName=&SSHPublicKeyId=&Encoding=&Action=&Version=#Action=GetSSHPublicKey")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?UserName=&SSHPublicKeyId=&Encoding=&Action=&Version=#Action=GetSSHPublicKey"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?UserName=&SSHPublicKeyId=&Encoding=&Action=&Version=#Action=GetSSHPublicKey")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?UserName=&SSHPublicKeyId=&Encoding=&Action=&Version=#Action=GetSSHPublicKey")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Encoding=&Action=&Version=#Action=GetSSHPublicKey');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetSSHPublicKey',
  params: {UserName: '', SSHPublicKeyId: '', Encoding: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Encoding=&Action=&Version=#Action=GetSSHPublicKey';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Encoding=&Action=&Version=#Action=GetSSHPublicKey',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?UserName=&SSHPublicKeyId=&Encoding=&Action=&Version=#Action=GetSSHPublicKey")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?UserName=&SSHPublicKeyId=&Encoding=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetSSHPublicKey',
  qs: {UserName: '', SSHPublicKeyId: '', Encoding: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=GetSSHPublicKey');

req.query({
  UserName: '',
  SSHPublicKeyId: '',
  Encoding: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetSSHPublicKey',
  params: {UserName: '', SSHPublicKeyId: '', Encoding: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Encoding=&Action=&Version=#Action=GetSSHPublicKey';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?UserName=&SSHPublicKeyId=&Encoding=&Action=&Version=#Action=GetSSHPublicKey"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?UserName=&SSHPublicKeyId=&Encoding=&Action=&Version=#Action=GetSSHPublicKey" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?UserName=&SSHPublicKeyId=&Encoding=&Action=&Version=#Action=GetSSHPublicKey",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Encoding=&Action=&Version=#Action=GetSSHPublicKey');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetSSHPublicKey');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'UserName' => '',
  'SSHPublicKeyId' => '',
  'Encoding' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetSSHPublicKey');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'UserName' => '',
  'SSHPublicKeyId' => '',
  'Encoding' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Encoding=&Action=&Version=#Action=GetSSHPublicKey' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Encoding=&Action=&Version=#Action=GetSSHPublicKey' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?UserName=&SSHPublicKeyId=&Encoding=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetSSHPublicKey"

querystring = {"UserName":"","SSHPublicKeyId":"","Encoding":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetSSHPublicKey"

queryString <- list(
  UserName = "",
  SSHPublicKeyId = "",
  Encoding = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?UserName=&SSHPublicKeyId=&Encoding=&Action=&Version=#Action=GetSSHPublicKey")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['UserName'] = ''
  req.params['SSHPublicKeyId'] = ''
  req.params['Encoding'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetSSHPublicKey";

    let querystring = [
        ("UserName", ""),
        ("SSHPublicKeyId", ""),
        ("Encoding", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Encoding=&Action=&Version=#Action=GetSSHPublicKey'
http GET '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Encoding=&Action=&Version=#Action=GetSSHPublicKey'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Encoding=&Action=&Version=#Action=GetSSHPublicKey'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?UserName=&SSHPublicKeyId=&Encoding=&Action=&Version=#Action=GetSSHPublicKey")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_GetServerCertificate
{{baseUrl}}/#Action=GetServerCertificate
QUERY PARAMS
ServerCertificateName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=GetServerCertificate");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=GetServerCertificate" {:query-params {:ServerCertificateName ""
                                                                                       :Action ""
                                                                                       :Version ""}})
require "http/client"

url = "{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=GetServerCertificate"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=GetServerCertificate"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=GetServerCertificate");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=GetServerCertificate"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?ServerCertificateName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=GetServerCertificate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=GetServerCertificate"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=GetServerCertificate")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=GetServerCertificate")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=GetServerCertificate');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetServerCertificate',
  params: {ServerCertificateName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=GetServerCertificate';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=GetServerCertificate',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=GetServerCertificate")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?ServerCertificateName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetServerCertificate',
  qs: {ServerCertificateName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=GetServerCertificate');

req.query({
  ServerCertificateName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetServerCertificate',
  params: {ServerCertificateName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=GetServerCertificate';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=GetServerCertificate"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=GetServerCertificate" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=GetServerCertificate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=GetServerCertificate');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetServerCertificate');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'ServerCertificateName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetServerCertificate');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'ServerCertificateName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=GetServerCertificate' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=GetServerCertificate' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?ServerCertificateName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetServerCertificate"

querystring = {"ServerCertificateName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetServerCertificate"

queryString <- list(
  ServerCertificateName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=GetServerCertificate")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['ServerCertificateName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetServerCertificate";

    let querystring = [
        ("ServerCertificateName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=GetServerCertificate'
http GET '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=GetServerCertificate'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=GetServerCertificate'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=GetServerCertificate")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_GetServiceLastAccessedDetails
{{baseUrl}}/#Action=GetServiceLastAccessedDetails
QUERY PARAMS
JobId
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?JobId=&Action=&Version=#Action=GetServiceLastAccessedDetails");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=GetServiceLastAccessedDetails" {:query-params {:JobId ""
                                                                                                :Action ""
                                                                                                :Version ""}})
require "http/client"

url = "{{baseUrl}}/?JobId=&Action=&Version=#Action=GetServiceLastAccessedDetails"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?JobId=&Action=&Version=#Action=GetServiceLastAccessedDetails"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?JobId=&Action=&Version=#Action=GetServiceLastAccessedDetails");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?JobId=&Action=&Version=#Action=GetServiceLastAccessedDetails"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?JobId=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?JobId=&Action=&Version=#Action=GetServiceLastAccessedDetails")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?JobId=&Action=&Version=#Action=GetServiceLastAccessedDetails"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?JobId=&Action=&Version=#Action=GetServiceLastAccessedDetails")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?JobId=&Action=&Version=#Action=GetServiceLastAccessedDetails")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?JobId=&Action=&Version=#Action=GetServiceLastAccessedDetails');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetServiceLastAccessedDetails',
  params: {JobId: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?JobId=&Action=&Version=#Action=GetServiceLastAccessedDetails';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?JobId=&Action=&Version=#Action=GetServiceLastAccessedDetails',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?JobId=&Action=&Version=#Action=GetServiceLastAccessedDetails")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?JobId=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetServiceLastAccessedDetails',
  qs: {JobId: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=GetServiceLastAccessedDetails');

req.query({
  JobId: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetServiceLastAccessedDetails',
  params: {JobId: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?JobId=&Action=&Version=#Action=GetServiceLastAccessedDetails';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?JobId=&Action=&Version=#Action=GetServiceLastAccessedDetails"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?JobId=&Action=&Version=#Action=GetServiceLastAccessedDetails" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?JobId=&Action=&Version=#Action=GetServiceLastAccessedDetails",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?JobId=&Action=&Version=#Action=GetServiceLastAccessedDetails');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetServiceLastAccessedDetails');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'JobId' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetServiceLastAccessedDetails');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'JobId' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?JobId=&Action=&Version=#Action=GetServiceLastAccessedDetails' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?JobId=&Action=&Version=#Action=GetServiceLastAccessedDetails' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?JobId=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetServiceLastAccessedDetails"

querystring = {"JobId":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetServiceLastAccessedDetails"

queryString <- list(
  JobId = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?JobId=&Action=&Version=#Action=GetServiceLastAccessedDetails")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['JobId'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetServiceLastAccessedDetails";

    let querystring = [
        ("JobId", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?JobId=&Action=&Version=#Action=GetServiceLastAccessedDetails'
http GET '{{baseUrl}}/?JobId=&Action=&Version=#Action=GetServiceLastAccessedDetails'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?JobId=&Action=&Version=#Action=GetServiceLastAccessedDetails'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?JobId=&Action=&Version=#Action=GetServiceLastAccessedDetails")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "IsTruncated": false,
  "JobCompletionDate": "2018-10-24T19:47:35.241Z",
  "JobCreationDate": "2018-10-24T19:47:31.466Z",
  "JobStatus": "COMPLETED",
  "ServicesLastAccessed": [
    {
      "LastAuthenticated": "2018-10-24T19:11:00Z",
      "LastAuthenticatedEntity": "arn:aws:iam::123456789012:user/AWSExampleUser01",
      "ServiceName": "AWS Identity and Access Management",
      "ServiceNamespace": "iam",
      "TotalAuthenticatedEntities": 2
    },
    {
      "ServiceName": "Amazon Simple Storage Service",
      "ServiceNamespace": "s3",
      "TotalAuthenticatedEntities": 0
    }
  ]
}
GET GET_GetServiceLastAccessedDetailsWithEntities
{{baseUrl}}/#Action=GetServiceLastAccessedDetailsWithEntities
QUERY PARAMS
JobId
ServiceNamespace
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?JobId=&ServiceNamespace=&Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=GetServiceLastAccessedDetailsWithEntities" {:query-params {:JobId ""
                                                                                                            :ServiceNamespace ""
                                                                                                            :Action ""
                                                                                                            :Version ""}})
require "http/client"

url = "{{baseUrl}}/?JobId=&ServiceNamespace=&Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?JobId=&ServiceNamespace=&Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?JobId=&ServiceNamespace=&Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?JobId=&ServiceNamespace=&Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?JobId=&ServiceNamespace=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?JobId=&ServiceNamespace=&Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?JobId=&ServiceNamespace=&Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?JobId=&ServiceNamespace=&Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?JobId=&ServiceNamespace=&Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?JobId=&ServiceNamespace=&Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetServiceLastAccessedDetailsWithEntities',
  params: {JobId: '', ServiceNamespace: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?JobId=&ServiceNamespace=&Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?JobId=&ServiceNamespace=&Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?JobId=&ServiceNamespace=&Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?JobId=&ServiceNamespace=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetServiceLastAccessedDetailsWithEntities',
  qs: {JobId: '', ServiceNamespace: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=GetServiceLastAccessedDetailsWithEntities');

req.query({
  JobId: '',
  ServiceNamespace: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetServiceLastAccessedDetailsWithEntities',
  params: {JobId: '', ServiceNamespace: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?JobId=&ServiceNamespace=&Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?JobId=&ServiceNamespace=&Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?JobId=&ServiceNamespace=&Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?JobId=&ServiceNamespace=&Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?JobId=&ServiceNamespace=&Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetServiceLastAccessedDetailsWithEntities');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'JobId' => '',
  'ServiceNamespace' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetServiceLastAccessedDetailsWithEntities');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'JobId' => '',
  'ServiceNamespace' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?JobId=&ServiceNamespace=&Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?JobId=&ServiceNamespace=&Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?JobId=&ServiceNamespace=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetServiceLastAccessedDetailsWithEntities"

querystring = {"JobId":"","ServiceNamespace":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetServiceLastAccessedDetailsWithEntities"

queryString <- list(
  JobId = "",
  ServiceNamespace = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?JobId=&ServiceNamespace=&Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['JobId'] = ''
  req.params['ServiceNamespace'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetServiceLastAccessedDetailsWithEntities";

    let querystring = [
        ("JobId", ""),
        ("ServiceNamespace", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?JobId=&ServiceNamespace=&Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities'
http GET '{{baseUrl}}/?JobId=&ServiceNamespace=&Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?JobId=&ServiceNamespace=&Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?JobId=&ServiceNamespace=&Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "EntityDetailsList": [
    {
      "EntityInfo": {
        "Arn": "arn:aws:iam::123456789012:user/AWSExampleUser01",
        "Id": "AIDAEX2EXAMPLEB6IGCDC",
        "Name": "AWSExampleUser01",
        "Path": "/",
        "Type": "USER"
      },
      "LastAuthenticated": "2018-10-24T19:10:00Z"
    },
    {
      "EntityInfo": {
        "Arn": "arn:aws:iam::123456789012:role/AWSExampleRole01",
        "Id": "AROAEAEXAMPLEIANXSIU4",
        "Name": "AWSExampleRole01",
        "Path": "/",
        "Type": "ROLE"
      }
    }
  ],
  "IsTruncated": false,
  "JobCompletionDate": "2018-10-24T19:47:35.241Z",
  "JobCreationDate": "2018-10-24T19:47:31.466Z",
  "JobStatus": "COMPLETED"
}
GET GET_GetServiceLinkedRoleDeletionStatus
{{baseUrl}}/#Action=GetServiceLinkedRoleDeletionStatus
QUERY PARAMS
DeletionTaskId
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?DeletionTaskId=&Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=GetServiceLinkedRoleDeletionStatus" {:query-params {:DeletionTaskId ""
                                                                                                     :Action ""
                                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?DeletionTaskId=&Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?DeletionTaskId=&Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DeletionTaskId=&Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?DeletionTaskId=&Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?DeletionTaskId=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?DeletionTaskId=&Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DeletionTaskId=&Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?DeletionTaskId=&Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DeletionTaskId=&Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?DeletionTaskId=&Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetServiceLinkedRoleDeletionStatus',
  params: {DeletionTaskId: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DeletionTaskId=&Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?DeletionTaskId=&Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?DeletionTaskId=&Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?DeletionTaskId=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetServiceLinkedRoleDeletionStatus',
  qs: {DeletionTaskId: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=GetServiceLinkedRoleDeletionStatus');

req.query({
  DeletionTaskId: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetServiceLinkedRoleDeletionStatus',
  params: {DeletionTaskId: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?DeletionTaskId=&Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?DeletionTaskId=&Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?DeletionTaskId=&Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DeletionTaskId=&Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?DeletionTaskId=&Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetServiceLinkedRoleDeletionStatus');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'DeletionTaskId' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetServiceLinkedRoleDeletionStatus');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'DeletionTaskId' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?DeletionTaskId=&Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?DeletionTaskId=&Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?DeletionTaskId=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetServiceLinkedRoleDeletionStatus"

querystring = {"DeletionTaskId":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetServiceLinkedRoleDeletionStatus"

queryString <- list(
  DeletionTaskId = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?DeletionTaskId=&Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['DeletionTaskId'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetServiceLinkedRoleDeletionStatus";

    let querystring = [
        ("DeletionTaskId", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?DeletionTaskId=&Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus'
http GET '{{baseUrl}}/?DeletionTaskId=&Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DeletionTaskId=&Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DeletionTaskId=&Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_GetUser
{{baseUrl}}/#Action=GetUser
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetUser");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=GetUser" {:query-params {:Action ""
                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetUser"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?Action=&Version=#Action=GetUser"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetUser");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetUser"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?Action=&Version=#Action=GetUser")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetUser"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetUser")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=GetUser")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?Action=&Version=#Action=GetUser');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetUser',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetUser';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?Action=&Version=#Action=GetUser',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetUser")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetUser',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=GetUser');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetUser',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetUser';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?Action=&Version=#Action=GetUser"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?Action=&Version=#Action=GetUser" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetUser",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?Action=&Version=#Action=GetUser');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetUser');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetUser');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetUser' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetUser' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetUser"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetUser"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetUser")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetUser";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?Action=&Version=#Action=GetUser'
http GET '{{baseUrl}}/?Action=&Version=#Action=GetUser'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetUser'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetUser")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "User": {
    "Arn": "arn:aws:iam::123456789012:user/Bob",
    "CreateDate": "2012-09-21T23:03:13Z",
    "Path": "/",
    "UserId": "AKIAIOSFODNN7EXAMPLE",
    "UserName": "Bob"
  }
}
GET GET_GetUserPolicy
{{baseUrl}}/#Action=GetUserPolicy
QUERY PARAMS
UserName
PolicyName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=GetUserPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=GetUserPolicy" {:query-params {:UserName ""
                                                                                :PolicyName ""
                                                                                :Action ""
                                                                                :Version ""}})
require "http/client"

url = "{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=GetUserPolicy"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=GetUserPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=GetUserPolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=GetUserPolicy"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?UserName=&PolicyName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=GetUserPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=GetUserPolicy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=GetUserPolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=GetUserPolicy")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=GetUserPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetUserPolicy',
  params: {UserName: '', PolicyName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=GetUserPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=GetUserPolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=GetUserPolicy")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?UserName=&PolicyName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetUserPolicy',
  qs: {UserName: '', PolicyName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=GetUserPolicy');

req.query({
  UserName: '',
  PolicyName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=GetUserPolicy',
  params: {UserName: '', PolicyName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=GetUserPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=GetUserPolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=GetUserPolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=GetUserPolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=GetUserPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetUserPolicy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'UserName' => '',
  'PolicyName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetUserPolicy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'UserName' => '',
  'PolicyName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=GetUserPolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=GetUserPolicy' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?UserName=&PolicyName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetUserPolicy"

querystring = {"UserName":"","PolicyName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetUserPolicy"

queryString <- list(
  UserName = "",
  PolicyName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=GetUserPolicy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['UserName'] = ''
  req.params['PolicyName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetUserPolicy";

    let querystring = [
        ("UserName", ""),
        ("PolicyName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=GetUserPolicy'
http GET '{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=GetUserPolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=GetUserPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?UserName=&PolicyName=&Action=&Version=#Action=GetUserPolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_ListAccessKeys
{{baseUrl}}/#Action=ListAccessKeys
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListAccessKeys" {:query-params {:Action ""
                                                                                 :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListAccessKeys',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListAccessKeys',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListAccessKeys');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListAccessKeys',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListAccessKeys');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListAccessKeys');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListAccessKeys"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListAccessKeys"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListAccessKeys";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys'
http GET '{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "AccessKeyMetadata": [
    {
      "AccessKeyId": "AKIA111111111EXAMPLE",
      "CreateDate": "2016-12-01T22:19:58Z",
      "Status": "Active",
      "UserName": "Alice"
    },
    {
      "AccessKeyId": "AKIA222222222EXAMPLE",
      "CreateDate": "2016-12-01T22:20:01Z",
      "Status": "Active",
      "UserName": "Alice"
    }
  ]
}
GET GET_ListAccountAliases
{{baseUrl}}/#Action=ListAccountAliases
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListAccountAliases" {:query-params {:Action ""
                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListAccountAliases',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListAccountAliases',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListAccountAliases');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListAccountAliases',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListAccountAliases');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListAccountAliases');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListAccountAliases"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListAccountAliases"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListAccountAliases";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases'
http GET '{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "AccountAliases": [
    "exmaple-corporation"
  ]
}
GET GET_ListAttachedGroupPolicies
{{baseUrl}}/#Action=ListAttachedGroupPolicies
QUERY PARAMS
GroupName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListAttachedGroupPolicies");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListAttachedGroupPolicies" {:query-params {:GroupName ""
                                                                                            :Action ""
                                                                                            :Version ""}})
require "http/client"

url = "{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListAttachedGroupPolicies"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListAttachedGroupPolicies"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListAttachedGroupPolicies");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListAttachedGroupPolicies"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?GroupName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListAttachedGroupPolicies")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListAttachedGroupPolicies"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListAttachedGroupPolicies")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListAttachedGroupPolicies")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListAttachedGroupPolicies');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListAttachedGroupPolicies',
  params: {GroupName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListAttachedGroupPolicies';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListAttachedGroupPolicies',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListAttachedGroupPolicies")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?GroupName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListAttachedGroupPolicies',
  qs: {GroupName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListAttachedGroupPolicies');

req.query({
  GroupName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListAttachedGroupPolicies',
  params: {GroupName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListAttachedGroupPolicies';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListAttachedGroupPolicies"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListAttachedGroupPolicies" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListAttachedGroupPolicies",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListAttachedGroupPolicies');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListAttachedGroupPolicies');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'GroupName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListAttachedGroupPolicies');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'GroupName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListAttachedGroupPolicies' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListAttachedGroupPolicies' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?GroupName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListAttachedGroupPolicies"

querystring = {"GroupName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListAttachedGroupPolicies"

queryString <- list(
  GroupName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListAttachedGroupPolicies")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['GroupName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListAttachedGroupPolicies";

    let querystring = [
        ("GroupName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListAttachedGroupPolicies'
http GET '{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListAttachedGroupPolicies'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListAttachedGroupPolicies'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListAttachedGroupPolicies")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_ListAttachedRolePolicies
{{baseUrl}}/#Action=ListAttachedRolePolicies
QUERY PARAMS
RoleName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListAttachedRolePolicies");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListAttachedRolePolicies" {:query-params {:RoleName ""
                                                                                           :Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListAttachedRolePolicies"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListAttachedRolePolicies"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListAttachedRolePolicies");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListAttachedRolePolicies"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?RoleName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListAttachedRolePolicies")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListAttachedRolePolicies"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListAttachedRolePolicies")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListAttachedRolePolicies")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListAttachedRolePolicies');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListAttachedRolePolicies',
  params: {RoleName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListAttachedRolePolicies';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListAttachedRolePolicies',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListAttachedRolePolicies")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?RoleName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListAttachedRolePolicies',
  qs: {RoleName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListAttachedRolePolicies');

req.query({
  RoleName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListAttachedRolePolicies',
  params: {RoleName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListAttachedRolePolicies';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListAttachedRolePolicies"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListAttachedRolePolicies" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListAttachedRolePolicies",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListAttachedRolePolicies');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListAttachedRolePolicies');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'RoleName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListAttachedRolePolicies');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'RoleName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListAttachedRolePolicies' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListAttachedRolePolicies' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?RoleName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListAttachedRolePolicies"

querystring = {"RoleName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListAttachedRolePolicies"

queryString <- list(
  RoleName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListAttachedRolePolicies")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['RoleName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListAttachedRolePolicies";

    let querystring = [
        ("RoleName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListAttachedRolePolicies'
http GET '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListAttachedRolePolicies'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListAttachedRolePolicies'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListAttachedRolePolicies")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_ListAttachedUserPolicies
{{baseUrl}}/#Action=ListAttachedUserPolicies
QUERY PARAMS
UserName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?UserName=&Action=&Version=#Action=ListAttachedUserPolicies");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListAttachedUserPolicies" {:query-params {:UserName ""
                                                                                           :Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?UserName=&Action=&Version=#Action=ListAttachedUserPolicies"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?UserName=&Action=&Version=#Action=ListAttachedUserPolicies"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?UserName=&Action=&Version=#Action=ListAttachedUserPolicies");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?UserName=&Action=&Version=#Action=ListAttachedUserPolicies"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?UserName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?UserName=&Action=&Version=#Action=ListAttachedUserPolicies")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?UserName=&Action=&Version=#Action=ListAttachedUserPolicies"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?UserName=&Action=&Version=#Action=ListAttachedUserPolicies")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?UserName=&Action=&Version=#Action=ListAttachedUserPolicies")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListAttachedUserPolicies');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListAttachedUserPolicies',
  params: {UserName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListAttachedUserPolicies';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListAttachedUserPolicies',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?UserName=&Action=&Version=#Action=ListAttachedUserPolicies")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?UserName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListAttachedUserPolicies',
  qs: {UserName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListAttachedUserPolicies');

req.query({
  UserName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListAttachedUserPolicies',
  params: {UserName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListAttachedUserPolicies';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?UserName=&Action=&Version=#Action=ListAttachedUserPolicies"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?UserName=&Action=&Version=#Action=ListAttachedUserPolicies" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?UserName=&Action=&Version=#Action=ListAttachedUserPolicies",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListAttachedUserPolicies');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListAttachedUserPolicies');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'UserName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListAttachedUserPolicies');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'UserName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListAttachedUserPolicies' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListAttachedUserPolicies' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?UserName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListAttachedUserPolicies"

querystring = {"UserName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListAttachedUserPolicies"

queryString <- list(
  UserName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?UserName=&Action=&Version=#Action=ListAttachedUserPolicies")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['UserName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListAttachedUserPolicies";

    let querystring = [
        ("UserName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListAttachedUserPolicies'
http GET '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListAttachedUserPolicies'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListAttachedUserPolicies'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?UserName=&Action=&Version=#Action=ListAttachedUserPolicies")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_ListEntitiesForPolicy
{{baseUrl}}/#Action=ListEntitiesForPolicy
QUERY PARAMS
PolicyArn
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListEntitiesForPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListEntitiesForPolicy" {:query-params {:PolicyArn ""
                                                                                        :Action ""
                                                                                        :Version ""}})
require "http/client"

url = "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListEntitiesForPolicy"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListEntitiesForPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListEntitiesForPolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListEntitiesForPolicy"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?PolicyArn=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListEntitiesForPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListEntitiesForPolicy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListEntitiesForPolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListEntitiesForPolicy")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListEntitiesForPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListEntitiesForPolicy',
  params: {PolicyArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListEntitiesForPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListEntitiesForPolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListEntitiesForPolicy")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?PolicyArn=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListEntitiesForPolicy',
  qs: {PolicyArn: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListEntitiesForPolicy');

req.query({
  PolicyArn: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListEntitiesForPolicy',
  params: {PolicyArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListEntitiesForPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListEntitiesForPolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListEntitiesForPolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListEntitiesForPolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListEntitiesForPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListEntitiesForPolicy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'PolicyArn' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListEntitiesForPolicy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'PolicyArn' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListEntitiesForPolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListEntitiesForPolicy' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?PolicyArn=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListEntitiesForPolicy"

querystring = {"PolicyArn":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListEntitiesForPolicy"

queryString <- list(
  PolicyArn = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListEntitiesForPolicy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['PolicyArn'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListEntitiesForPolicy";

    let querystring = [
        ("PolicyArn", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListEntitiesForPolicy'
http GET '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListEntitiesForPolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListEntitiesForPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListEntitiesForPolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_ListGroupPolicies
{{baseUrl}}/#Action=ListGroupPolicies
QUERY PARAMS
GroupName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListGroupPolicies");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListGroupPolicies" {:query-params {:GroupName ""
                                                                                    :Action ""
                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListGroupPolicies"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListGroupPolicies"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListGroupPolicies");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListGroupPolicies"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?GroupName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListGroupPolicies")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListGroupPolicies"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListGroupPolicies")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListGroupPolicies")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListGroupPolicies');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListGroupPolicies',
  params: {GroupName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListGroupPolicies';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListGroupPolicies',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListGroupPolicies")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?GroupName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListGroupPolicies',
  qs: {GroupName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListGroupPolicies');

req.query({
  GroupName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListGroupPolicies',
  params: {GroupName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListGroupPolicies';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListGroupPolicies"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListGroupPolicies" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListGroupPolicies",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListGroupPolicies');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListGroupPolicies');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'GroupName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListGroupPolicies');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'GroupName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListGroupPolicies' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListGroupPolicies' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?GroupName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListGroupPolicies"

querystring = {"GroupName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListGroupPolicies"

queryString <- list(
  GroupName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListGroupPolicies")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['GroupName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListGroupPolicies";

    let querystring = [
        ("GroupName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListGroupPolicies'
http GET '{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListGroupPolicies'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListGroupPolicies'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?GroupName=&Action=&Version=#Action=ListGroupPolicies")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "PolicyNames": [
    "AdminRoot",
    "KeyPolicy"
  ]
}
GET GET_ListGroups
{{baseUrl}}/#Action=ListGroups
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListGroups");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListGroups" {:query-params {:Action ""
                                                                             :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListGroups"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?Action=&Version=#Action=ListGroups"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListGroups");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListGroups"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?Action=&Version=#Action=ListGroups")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListGroups"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListGroups")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=ListGroups")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?Action=&Version=#Action=ListGroups');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListGroups',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListGroups';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?Action=&Version=#Action=ListGroups',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListGroups")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListGroups',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListGroups');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListGroups',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListGroups';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?Action=&Version=#Action=ListGroups"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?Action=&Version=#Action=ListGroups" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListGroups",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?Action=&Version=#Action=ListGroups');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListGroups');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListGroups');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListGroups' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListGroups' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListGroups"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListGroups"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListGroups")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListGroups";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?Action=&Version=#Action=ListGroups'
http GET '{{baseUrl}}/?Action=&Version=#Action=ListGroups'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListGroups'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListGroups")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "Groups": [
    {
      "Arn": "arn:aws:iam::123456789012:group/Admins",
      "CreateDate": "2016-12-15T21:40:08.121Z",
      "GroupId": "AGPA1111111111EXAMPLE",
      "GroupName": "Admins",
      "Path": "/division_abc/subdivision_xyz/"
    },
    {
      "Arn": "arn:aws:iam::123456789012:group/division_abc/subdivision_xyz/product_1234/engineering/Test",
      "CreateDate": "2016-11-30T14:10:01.156Z",
      "GroupId": "AGP22222222222EXAMPLE",
      "GroupName": "Test",
      "Path": "/division_abc/subdivision_xyz/product_1234/engineering/"
    },
    {
      "Arn": "arn:aws:iam::123456789012:group/division_abc/subdivision_xyz/product_1234/Managers",
      "CreateDate": "2016-06-12T20:14:52.032Z",
      "GroupId": "AGPI3333333333EXAMPLE",
      "GroupName": "Managers",
      "Path": "/division_abc/subdivision_xyz/product_1234/"
    }
  ]
}
GET GET_ListGroupsForUser
{{baseUrl}}/#Action=ListGroupsForUser
QUERY PARAMS
UserName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?UserName=&Action=&Version=#Action=ListGroupsForUser");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListGroupsForUser" {:query-params {:UserName ""
                                                                                    :Action ""
                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?UserName=&Action=&Version=#Action=ListGroupsForUser"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?UserName=&Action=&Version=#Action=ListGroupsForUser"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?UserName=&Action=&Version=#Action=ListGroupsForUser");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?UserName=&Action=&Version=#Action=ListGroupsForUser"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?UserName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?UserName=&Action=&Version=#Action=ListGroupsForUser")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?UserName=&Action=&Version=#Action=ListGroupsForUser"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?UserName=&Action=&Version=#Action=ListGroupsForUser")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?UserName=&Action=&Version=#Action=ListGroupsForUser")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListGroupsForUser');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListGroupsForUser',
  params: {UserName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListGroupsForUser';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListGroupsForUser',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?UserName=&Action=&Version=#Action=ListGroupsForUser")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?UserName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListGroupsForUser',
  qs: {UserName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListGroupsForUser');

req.query({
  UserName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListGroupsForUser',
  params: {UserName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListGroupsForUser';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?UserName=&Action=&Version=#Action=ListGroupsForUser"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?UserName=&Action=&Version=#Action=ListGroupsForUser" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?UserName=&Action=&Version=#Action=ListGroupsForUser",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListGroupsForUser');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListGroupsForUser');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'UserName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListGroupsForUser');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'UserName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListGroupsForUser' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListGroupsForUser' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?UserName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListGroupsForUser"

querystring = {"UserName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListGroupsForUser"

queryString <- list(
  UserName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?UserName=&Action=&Version=#Action=ListGroupsForUser")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['UserName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListGroupsForUser";

    let querystring = [
        ("UserName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListGroupsForUser'
http GET '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListGroupsForUser'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListGroupsForUser'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?UserName=&Action=&Version=#Action=ListGroupsForUser")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "Groups": [
    {
      "Arn": "arn:aws:iam::123456789012:group/division_abc/subdivision_xyz/product_1234/engineering/Test",
      "CreateDate": "2016-11-30T14:10:01.156Z",
      "GroupId": "AGP2111111111EXAMPLE",
      "GroupName": "Test",
      "Path": "/division_abc/subdivision_xyz/product_1234/engineering/"
    },
    {
      "Arn": "arn:aws:iam::123456789012:group/division_abc/subdivision_xyz/product_1234/Managers",
      "CreateDate": "2016-06-12T20:14:52.032Z",
      "GroupId": "AGPI222222222SEXAMPLE",
      "GroupName": "Managers",
      "Path": "/division_abc/subdivision_xyz/product_1234/"
    }
  ]
}
GET GET_ListInstanceProfileTags
{{baseUrl}}/#Action=ListInstanceProfileTags
QUERY PARAMS
InstanceProfileName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=ListInstanceProfileTags");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListInstanceProfileTags" {:query-params {:InstanceProfileName ""
                                                                                          :Action ""
                                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=ListInstanceProfileTags"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=ListInstanceProfileTags"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=ListInstanceProfileTags");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=ListInstanceProfileTags"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?InstanceProfileName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=ListInstanceProfileTags")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=ListInstanceProfileTags"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=ListInstanceProfileTags")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=ListInstanceProfileTags")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=ListInstanceProfileTags');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListInstanceProfileTags',
  params: {InstanceProfileName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=ListInstanceProfileTags';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=ListInstanceProfileTags',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=ListInstanceProfileTags")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?InstanceProfileName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListInstanceProfileTags',
  qs: {InstanceProfileName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListInstanceProfileTags');

req.query({
  InstanceProfileName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListInstanceProfileTags',
  params: {InstanceProfileName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=ListInstanceProfileTags';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=ListInstanceProfileTags"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=ListInstanceProfileTags" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=ListInstanceProfileTags",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=ListInstanceProfileTags');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListInstanceProfileTags');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'InstanceProfileName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListInstanceProfileTags');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'InstanceProfileName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=ListInstanceProfileTags' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=ListInstanceProfileTags' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?InstanceProfileName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListInstanceProfileTags"

querystring = {"InstanceProfileName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListInstanceProfileTags"

queryString <- list(
  InstanceProfileName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=ListInstanceProfileTags")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['InstanceProfileName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListInstanceProfileTags";

    let querystring = [
        ("InstanceProfileName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=ListInstanceProfileTags'
http GET '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=ListInstanceProfileTags'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=ListInstanceProfileTags'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?InstanceProfileName=&Action=&Version=#Action=ListInstanceProfileTags")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_ListInstanceProfiles
{{baseUrl}}/#Action=ListInstanceProfiles
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListInstanceProfiles" {:query-params {:Action ""
                                                                                       :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListInstanceProfiles',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListInstanceProfiles',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListInstanceProfiles');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListInstanceProfiles',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListInstanceProfiles');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListInstanceProfiles');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListInstanceProfiles"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListInstanceProfiles"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListInstanceProfiles";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles'
http GET '{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_ListInstanceProfilesForRole
{{baseUrl}}/#Action=ListInstanceProfilesForRole
QUERY PARAMS
RoleName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListInstanceProfilesForRole");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListInstanceProfilesForRole" {:query-params {:RoleName ""
                                                                                              :Action ""
                                                                                              :Version ""}})
require "http/client"

url = "{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListInstanceProfilesForRole"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListInstanceProfilesForRole"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListInstanceProfilesForRole");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListInstanceProfilesForRole"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?RoleName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListInstanceProfilesForRole")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListInstanceProfilesForRole"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListInstanceProfilesForRole")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListInstanceProfilesForRole")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListInstanceProfilesForRole');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListInstanceProfilesForRole',
  params: {RoleName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListInstanceProfilesForRole';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListInstanceProfilesForRole',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListInstanceProfilesForRole")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?RoleName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListInstanceProfilesForRole',
  qs: {RoleName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListInstanceProfilesForRole');

req.query({
  RoleName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListInstanceProfilesForRole',
  params: {RoleName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListInstanceProfilesForRole';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListInstanceProfilesForRole"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListInstanceProfilesForRole" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListInstanceProfilesForRole",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListInstanceProfilesForRole');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListInstanceProfilesForRole');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'RoleName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListInstanceProfilesForRole');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'RoleName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListInstanceProfilesForRole' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListInstanceProfilesForRole' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?RoleName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListInstanceProfilesForRole"

querystring = {"RoleName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListInstanceProfilesForRole"

queryString <- list(
  RoleName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListInstanceProfilesForRole")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['RoleName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListInstanceProfilesForRole";

    let querystring = [
        ("RoleName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListInstanceProfilesForRole'
http GET '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListInstanceProfilesForRole'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListInstanceProfilesForRole'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListInstanceProfilesForRole")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_ListMFADeviceTags
{{baseUrl}}/#Action=ListMFADeviceTags
QUERY PARAMS
SerialNumber
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=ListMFADeviceTags");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListMFADeviceTags" {:query-params {:SerialNumber ""
                                                                                    :Action ""
                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=ListMFADeviceTags"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=ListMFADeviceTags"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=ListMFADeviceTags");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=ListMFADeviceTags"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?SerialNumber=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=ListMFADeviceTags")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=ListMFADeviceTags"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=ListMFADeviceTags")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=ListMFADeviceTags")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=ListMFADeviceTags');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListMFADeviceTags',
  params: {SerialNumber: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=ListMFADeviceTags';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=ListMFADeviceTags',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=ListMFADeviceTags")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?SerialNumber=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListMFADeviceTags',
  qs: {SerialNumber: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListMFADeviceTags');

req.query({
  SerialNumber: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListMFADeviceTags',
  params: {SerialNumber: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=ListMFADeviceTags';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=ListMFADeviceTags"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=ListMFADeviceTags" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=ListMFADeviceTags",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=ListMFADeviceTags');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListMFADeviceTags');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'SerialNumber' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListMFADeviceTags');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'SerialNumber' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=ListMFADeviceTags' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=ListMFADeviceTags' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?SerialNumber=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListMFADeviceTags"

querystring = {"SerialNumber":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListMFADeviceTags"

queryString <- list(
  SerialNumber = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=ListMFADeviceTags")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['SerialNumber'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListMFADeviceTags";

    let querystring = [
        ("SerialNumber", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=ListMFADeviceTags'
http GET '{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=ListMFADeviceTags'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=ListMFADeviceTags'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?SerialNumber=&Action=&Version=#Action=ListMFADeviceTags")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_ListMFADevices
{{baseUrl}}/#Action=ListMFADevices
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListMFADevices");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListMFADevices" {:query-params {:Action ""
                                                                                 :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListMFADevices"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?Action=&Version=#Action=ListMFADevices"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListMFADevices");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListMFADevices"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?Action=&Version=#Action=ListMFADevices")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListMFADevices"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListMFADevices")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=ListMFADevices")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?Action=&Version=#Action=ListMFADevices');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListMFADevices',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListMFADevices';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?Action=&Version=#Action=ListMFADevices',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListMFADevices")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListMFADevices',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListMFADevices');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListMFADevices',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListMFADevices';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?Action=&Version=#Action=ListMFADevices"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?Action=&Version=#Action=ListMFADevices" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListMFADevices",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?Action=&Version=#Action=ListMFADevices');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListMFADevices');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListMFADevices');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListMFADevices' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListMFADevices' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListMFADevices"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListMFADevices"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListMFADevices")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListMFADevices";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?Action=&Version=#Action=ListMFADevices'
http GET '{{baseUrl}}/?Action=&Version=#Action=ListMFADevices'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListMFADevices'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListMFADevices")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_ListOpenIDConnectProviderTags
{{baseUrl}}/#Action=ListOpenIDConnectProviderTags
QUERY PARAMS
OpenIDConnectProviderArn
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=ListOpenIDConnectProviderTags");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListOpenIDConnectProviderTags" {:query-params {:OpenIDConnectProviderArn ""
                                                                                                :Action ""
                                                                                                :Version ""}})
require "http/client"

url = "{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=ListOpenIDConnectProviderTags"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=ListOpenIDConnectProviderTags"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=ListOpenIDConnectProviderTags");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=ListOpenIDConnectProviderTags"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?OpenIDConnectProviderArn=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=ListOpenIDConnectProviderTags")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=ListOpenIDConnectProviderTags"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=ListOpenIDConnectProviderTags")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=ListOpenIDConnectProviderTags")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=ListOpenIDConnectProviderTags');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListOpenIDConnectProviderTags',
  params: {OpenIDConnectProviderArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=ListOpenIDConnectProviderTags';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=ListOpenIDConnectProviderTags',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=ListOpenIDConnectProviderTags")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?OpenIDConnectProviderArn=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListOpenIDConnectProviderTags',
  qs: {OpenIDConnectProviderArn: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListOpenIDConnectProviderTags');

req.query({
  OpenIDConnectProviderArn: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListOpenIDConnectProviderTags',
  params: {OpenIDConnectProviderArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=ListOpenIDConnectProviderTags';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=ListOpenIDConnectProviderTags"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=ListOpenIDConnectProviderTags" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=ListOpenIDConnectProviderTags",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=ListOpenIDConnectProviderTags');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListOpenIDConnectProviderTags');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'OpenIDConnectProviderArn' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListOpenIDConnectProviderTags');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'OpenIDConnectProviderArn' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=ListOpenIDConnectProviderTags' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=ListOpenIDConnectProviderTags' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?OpenIDConnectProviderArn=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListOpenIDConnectProviderTags"

querystring = {"OpenIDConnectProviderArn":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListOpenIDConnectProviderTags"

queryString <- list(
  OpenIDConnectProviderArn = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=ListOpenIDConnectProviderTags")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['OpenIDConnectProviderArn'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListOpenIDConnectProviderTags";

    let querystring = [
        ("OpenIDConnectProviderArn", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=ListOpenIDConnectProviderTags'
http GET '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=ListOpenIDConnectProviderTags'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=ListOpenIDConnectProviderTags'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?OpenIDConnectProviderArn=&Action=&Version=#Action=ListOpenIDConnectProviderTags")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_ListOpenIDConnectProviders
{{baseUrl}}/#Action=ListOpenIDConnectProviders
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListOpenIDConnectProviders" {:query-params {:Action ""
                                                                                             :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListOpenIDConnectProviders',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListOpenIDConnectProviders',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListOpenIDConnectProviders');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListOpenIDConnectProviders',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListOpenIDConnectProviders');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListOpenIDConnectProviders');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListOpenIDConnectProviders"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListOpenIDConnectProviders"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListOpenIDConnectProviders";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders'
http GET '{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_ListPolicies
{{baseUrl}}/#Action=ListPolicies
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListPolicies");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListPolicies" {:query-params {:Action ""
                                                                               :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListPolicies"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?Action=&Version=#Action=ListPolicies"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListPolicies");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListPolicies"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?Action=&Version=#Action=ListPolicies")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListPolicies"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListPolicies")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=ListPolicies")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?Action=&Version=#Action=ListPolicies');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListPolicies',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListPolicies';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?Action=&Version=#Action=ListPolicies',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListPolicies")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListPolicies',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListPolicies');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListPolicies',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListPolicies';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?Action=&Version=#Action=ListPolicies"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?Action=&Version=#Action=ListPolicies" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListPolicies",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?Action=&Version=#Action=ListPolicies');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListPolicies');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListPolicies');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListPolicies' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListPolicies' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListPolicies"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListPolicies"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListPolicies")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListPolicies";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?Action=&Version=#Action=ListPolicies'
http GET '{{baseUrl}}/?Action=&Version=#Action=ListPolicies'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListPolicies'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListPolicies")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_ListPoliciesGrantingServiceAccess
{{baseUrl}}/#Action=ListPoliciesGrantingServiceAccess
QUERY PARAMS
Arn
ServiceNamespaces
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Arn=&ServiceNamespaces=&Action=&Version=#Action=ListPoliciesGrantingServiceAccess");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListPoliciesGrantingServiceAccess" {:query-params {:Arn ""
                                                                                                    :ServiceNamespaces ""
                                                                                                    :Action ""
                                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Arn=&ServiceNamespaces=&Action=&Version=#Action=ListPoliciesGrantingServiceAccess"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?Arn=&ServiceNamespaces=&Action=&Version=#Action=ListPoliciesGrantingServiceAccess"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Arn=&ServiceNamespaces=&Action=&Version=#Action=ListPoliciesGrantingServiceAccess");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Arn=&ServiceNamespaces=&Action=&Version=#Action=ListPoliciesGrantingServiceAccess"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?Arn=&ServiceNamespaces=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?Arn=&ServiceNamespaces=&Action=&Version=#Action=ListPoliciesGrantingServiceAccess")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Arn=&ServiceNamespaces=&Action=&Version=#Action=ListPoliciesGrantingServiceAccess"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?Arn=&ServiceNamespaces=&Action=&Version=#Action=ListPoliciesGrantingServiceAccess")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Arn=&ServiceNamespaces=&Action=&Version=#Action=ListPoliciesGrantingServiceAccess")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?Arn=&ServiceNamespaces=&Action=&Version=#Action=ListPoliciesGrantingServiceAccess');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListPoliciesGrantingServiceAccess',
  params: {Arn: '', ServiceNamespaces: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Arn=&ServiceNamespaces=&Action=&Version=#Action=ListPoliciesGrantingServiceAccess';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?Arn=&ServiceNamespaces=&Action=&Version=#Action=ListPoliciesGrantingServiceAccess',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Arn=&ServiceNamespaces=&Action=&Version=#Action=ListPoliciesGrantingServiceAccess")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Arn=&ServiceNamespaces=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListPoliciesGrantingServiceAccess',
  qs: {Arn: '', ServiceNamespaces: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListPoliciesGrantingServiceAccess');

req.query({
  Arn: '',
  ServiceNamespaces: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListPoliciesGrantingServiceAccess',
  params: {Arn: '', ServiceNamespaces: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Arn=&ServiceNamespaces=&Action=&Version=#Action=ListPoliciesGrantingServiceAccess';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?Arn=&ServiceNamespaces=&Action=&Version=#Action=ListPoliciesGrantingServiceAccess"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?Arn=&ServiceNamespaces=&Action=&Version=#Action=ListPoliciesGrantingServiceAccess" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Arn=&ServiceNamespaces=&Action=&Version=#Action=ListPoliciesGrantingServiceAccess",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?Arn=&ServiceNamespaces=&Action=&Version=#Action=ListPoliciesGrantingServiceAccess');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListPoliciesGrantingServiceAccess');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Arn' => '',
  'ServiceNamespaces' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListPoliciesGrantingServiceAccess');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Arn' => '',
  'ServiceNamespaces' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Arn=&ServiceNamespaces=&Action=&Version=#Action=ListPoliciesGrantingServiceAccess' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Arn=&ServiceNamespaces=&Action=&Version=#Action=ListPoliciesGrantingServiceAccess' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?Arn=&ServiceNamespaces=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListPoliciesGrantingServiceAccess"

querystring = {"Arn":"","ServiceNamespaces":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListPoliciesGrantingServiceAccess"

queryString <- list(
  Arn = "",
  ServiceNamespaces = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Arn=&ServiceNamespaces=&Action=&Version=#Action=ListPoliciesGrantingServiceAccess")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['Arn'] = ''
  req.params['ServiceNamespaces'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListPoliciesGrantingServiceAccess";

    let querystring = [
        ("Arn", ""),
        ("ServiceNamespaces", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?Arn=&ServiceNamespaces=&Action=&Version=#Action=ListPoliciesGrantingServiceAccess'
http GET '{{baseUrl}}/?Arn=&ServiceNamespaces=&Action=&Version=#Action=ListPoliciesGrantingServiceAccess'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Arn=&ServiceNamespaces=&Action=&Version=#Action=ListPoliciesGrantingServiceAccess'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Arn=&ServiceNamespaces=&Action=&Version=#Action=ListPoliciesGrantingServiceAccess")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "IsTruncated": false,
  "PoliciesGrantingServiceAccess": [
    {
      "Policies": [
        {
          "PolicyArn": "arn:aws:iam::123456789012:policy/ExampleIamPolicy",
          "PolicyName": "ExampleIamPolicy",
          "PolicyType": "MANAGED"
        },
        {
          "EntityName": "AWSExampleGroup1",
          "EntityType": "GROUP",
          "PolicyName": "ExampleGroup1Policy",
          "PolicyType": "INLINE"
        }
      ],
      "ServiceNamespace": "iam"
    },
    {
      "Policies": [
        {
          "PolicyArn": "arn:aws:iam::123456789012:policy/ExampleEc2Policy",
          "PolicyName": "ExampleEc2Policy",
          "PolicyType": "MANAGED"
        }
      ],
      "ServiceNamespace": "ec2"
    }
  ]
}
GET GET_ListPolicyTags
{{baseUrl}}/#Action=ListPolicyTags
QUERY PARAMS
PolicyArn
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyTags");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListPolicyTags" {:query-params {:PolicyArn ""
                                                                                 :Action ""
                                                                                 :Version ""}})
require "http/client"

url = "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyTags"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyTags"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyTags");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyTags"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?PolicyArn=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyTags")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyTags"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyTags")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyTags")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyTags');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListPolicyTags',
  params: {PolicyArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyTags';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyTags',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyTags")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?PolicyArn=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListPolicyTags',
  qs: {PolicyArn: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListPolicyTags');

req.query({
  PolicyArn: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListPolicyTags',
  params: {PolicyArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyTags';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyTags"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyTags" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyTags",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyTags');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListPolicyTags');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'PolicyArn' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListPolicyTags');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'PolicyArn' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyTags' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyTags' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?PolicyArn=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListPolicyTags"

querystring = {"PolicyArn":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListPolicyTags"

queryString <- list(
  PolicyArn = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyTags")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['PolicyArn'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListPolicyTags";

    let querystring = [
        ("PolicyArn", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyTags'
http GET '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyTags'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyTags'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyTags")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_ListPolicyVersions
{{baseUrl}}/#Action=ListPolicyVersions
QUERY PARAMS
PolicyArn
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyVersions");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListPolicyVersions" {:query-params {:PolicyArn ""
                                                                                     :Action ""
                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyVersions"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyVersions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyVersions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyVersions"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?PolicyArn=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyVersions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyVersions"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyVersions")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyVersions")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyVersions');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListPolicyVersions',
  params: {PolicyArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyVersions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyVersions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyVersions")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?PolicyArn=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListPolicyVersions',
  qs: {PolicyArn: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListPolicyVersions');

req.query({
  PolicyArn: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListPolicyVersions',
  params: {PolicyArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyVersions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyVersions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyVersions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyVersions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyVersions');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListPolicyVersions');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'PolicyArn' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListPolicyVersions');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'PolicyArn' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyVersions' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyVersions' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?PolicyArn=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListPolicyVersions"

querystring = {"PolicyArn":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListPolicyVersions"

queryString <- list(
  PolicyArn = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyVersions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['PolicyArn'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListPolicyVersions";

    let querystring = [
        ("PolicyArn", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyVersions'
http GET '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyVersions'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyVersions'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?PolicyArn=&Action=&Version=#Action=ListPolicyVersions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_ListRolePolicies
{{baseUrl}}/#Action=ListRolePolicies
QUERY PARAMS
RoleName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRolePolicies");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListRolePolicies" {:query-params {:RoleName ""
                                                                                   :Action ""
                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRolePolicies"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRolePolicies"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRolePolicies");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRolePolicies"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?RoleName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRolePolicies")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRolePolicies"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRolePolicies")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRolePolicies")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRolePolicies');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListRolePolicies',
  params: {RoleName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRolePolicies';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRolePolicies',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRolePolicies")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?RoleName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListRolePolicies',
  qs: {RoleName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListRolePolicies');

req.query({
  RoleName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListRolePolicies',
  params: {RoleName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRolePolicies';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRolePolicies"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRolePolicies" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRolePolicies",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRolePolicies');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListRolePolicies');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'RoleName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListRolePolicies');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'RoleName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRolePolicies' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRolePolicies' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?RoleName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListRolePolicies"

querystring = {"RoleName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListRolePolicies"

queryString <- list(
  RoleName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRolePolicies")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['RoleName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListRolePolicies";

    let querystring = [
        ("RoleName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRolePolicies'
http GET '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRolePolicies'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRolePolicies'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRolePolicies")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_ListRoleTags
{{baseUrl}}/#Action=ListRoleTags
QUERY PARAMS
RoleName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRoleTags");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListRoleTags" {:query-params {:RoleName ""
                                                                               :Action ""
                                                                               :Version ""}})
require "http/client"

url = "{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRoleTags"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRoleTags"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRoleTags");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRoleTags"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?RoleName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRoleTags")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRoleTags"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRoleTags")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRoleTags")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRoleTags');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListRoleTags',
  params: {RoleName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRoleTags';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRoleTags',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRoleTags")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?RoleName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListRoleTags',
  qs: {RoleName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListRoleTags');

req.query({
  RoleName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListRoleTags',
  params: {RoleName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRoleTags';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRoleTags"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRoleTags" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRoleTags",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRoleTags');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListRoleTags');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'RoleName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListRoleTags');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'RoleName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRoleTags' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRoleTags' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?RoleName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListRoleTags"

querystring = {"RoleName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListRoleTags"

queryString <- list(
  RoleName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRoleTags")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['RoleName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListRoleTags";

    let querystring = [
        ("RoleName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRoleTags'
http GET '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRoleTags'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRoleTags'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?RoleName=&Action=&Version=#Action=ListRoleTags")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "IsTruncated": false,
  "Tags": [
    {
      "Key": "Dept",
      "Value": "12345"
    },
    {
      "Key": "Team",
      "Value": "Accounting"
    }
  ]
}
GET GET_ListRoles
{{baseUrl}}/#Action=ListRoles
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListRoles");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListRoles" {:query-params {:Action ""
                                                                            :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListRoles"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?Action=&Version=#Action=ListRoles"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListRoles");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListRoles"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?Action=&Version=#Action=ListRoles")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListRoles"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListRoles")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=ListRoles")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?Action=&Version=#Action=ListRoles');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListRoles',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListRoles';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?Action=&Version=#Action=ListRoles',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListRoles")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListRoles',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListRoles');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListRoles',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListRoles';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?Action=&Version=#Action=ListRoles"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?Action=&Version=#Action=ListRoles" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListRoles",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?Action=&Version=#Action=ListRoles');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListRoles');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListRoles');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListRoles' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListRoles' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListRoles"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListRoles"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListRoles")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListRoles";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?Action=&Version=#Action=ListRoles'
http GET '{{baseUrl}}/?Action=&Version=#Action=ListRoles'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListRoles'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListRoles")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_ListSAMLProviderTags
{{baseUrl}}/#Action=ListSAMLProviderTags
QUERY PARAMS
SAMLProviderArn
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=ListSAMLProviderTags");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListSAMLProviderTags" {:query-params {:SAMLProviderArn ""
                                                                                       :Action ""
                                                                                       :Version ""}})
require "http/client"

url = "{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=ListSAMLProviderTags"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=ListSAMLProviderTags"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=ListSAMLProviderTags");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=ListSAMLProviderTags"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?SAMLProviderArn=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=ListSAMLProviderTags")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=ListSAMLProviderTags"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=ListSAMLProviderTags")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=ListSAMLProviderTags")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=ListSAMLProviderTags');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListSAMLProviderTags',
  params: {SAMLProviderArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=ListSAMLProviderTags';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=ListSAMLProviderTags',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=ListSAMLProviderTags")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?SAMLProviderArn=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListSAMLProviderTags',
  qs: {SAMLProviderArn: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListSAMLProviderTags');

req.query({
  SAMLProviderArn: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListSAMLProviderTags',
  params: {SAMLProviderArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=ListSAMLProviderTags';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=ListSAMLProviderTags"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=ListSAMLProviderTags" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=ListSAMLProviderTags",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=ListSAMLProviderTags');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListSAMLProviderTags');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'SAMLProviderArn' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListSAMLProviderTags');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'SAMLProviderArn' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=ListSAMLProviderTags' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=ListSAMLProviderTags' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?SAMLProviderArn=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListSAMLProviderTags"

querystring = {"SAMLProviderArn":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListSAMLProviderTags"

queryString <- list(
  SAMLProviderArn = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=ListSAMLProviderTags")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['SAMLProviderArn'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListSAMLProviderTags";

    let querystring = [
        ("SAMLProviderArn", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=ListSAMLProviderTags'
http GET '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=ListSAMLProviderTags'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=ListSAMLProviderTags'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?SAMLProviderArn=&Action=&Version=#Action=ListSAMLProviderTags")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_ListSAMLProviders
{{baseUrl}}/#Action=ListSAMLProviders
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListSAMLProviders" {:query-params {:Action ""
                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListSAMLProviders',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListSAMLProviders',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListSAMLProviders');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListSAMLProviders',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListSAMLProviders');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListSAMLProviders');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListSAMLProviders"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListSAMLProviders"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListSAMLProviders";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders'
http GET '{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_ListSSHPublicKeys
{{baseUrl}}/#Action=ListSSHPublicKeys
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListSSHPublicKeys" {:query-params {:Action ""
                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListSSHPublicKeys',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListSSHPublicKeys',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListSSHPublicKeys');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListSSHPublicKeys',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListSSHPublicKeys');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListSSHPublicKeys');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListSSHPublicKeys"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListSSHPublicKeys"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListSSHPublicKeys";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys'
http GET '{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_ListServerCertificateTags
{{baseUrl}}/#Action=ListServerCertificateTags
QUERY PARAMS
ServerCertificateName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=ListServerCertificateTags");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListServerCertificateTags" {:query-params {:ServerCertificateName ""
                                                                                            :Action ""
                                                                                            :Version ""}})
require "http/client"

url = "{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=ListServerCertificateTags"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=ListServerCertificateTags"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=ListServerCertificateTags");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=ListServerCertificateTags"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?ServerCertificateName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=ListServerCertificateTags")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=ListServerCertificateTags"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=ListServerCertificateTags")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=ListServerCertificateTags")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=ListServerCertificateTags');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListServerCertificateTags',
  params: {ServerCertificateName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=ListServerCertificateTags';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=ListServerCertificateTags',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=ListServerCertificateTags")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?ServerCertificateName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListServerCertificateTags',
  qs: {ServerCertificateName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListServerCertificateTags');

req.query({
  ServerCertificateName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListServerCertificateTags',
  params: {ServerCertificateName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=ListServerCertificateTags';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=ListServerCertificateTags"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=ListServerCertificateTags" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=ListServerCertificateTags",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=ListServerCertificateTags');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListServerCertificateTags');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'ServerCertificateName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListServerCertificateTags');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'ServerCertificateName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=ListServerCertificateTags' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=ListServerCertificateTags' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?ServerCertificateName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListServerCertificateTags"

querystring = {"ServerCertificateName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListServerCertificateTags"

queryString <- list(
  ServerCertificateName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=ListServerCertificateTags")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['ServerCertificateName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListServerCertificateTags";

    let querystring = [
        ("ServerCertificateName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=ListServerCertificateTags'
http GET '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=ListServerCertificateTags'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=ListServerCertificateTags'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=ListServerCertificateTags")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_ListServerCertificates
{{baseUrl}}/#Action=ListServerCertificates
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListServerCertificates" {:query-params {:Action ""
                                                                                         :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListServerCertificates',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListServerCertificates',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListServerCertificates');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListServerCertificates',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListServerCertificates');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListServerCertificates');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListServerCertificates"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListServerCertificates"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListServerCertificates";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates'
http GET '{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_ListServiceSpecificCredentials
{{baseUrl}}/#Action=ListServiceSpecificCredentials
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListServiceSpecificCredentials" {:query-params {:Action ""
                                                                                                 :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListServiceSpecificCredentials',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListServiceSpecificCredentials',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListServiceSpecificCredentials');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListServiceSpecificCredentials',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListServiceSpecificCredentials');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListServiceSpecificCredentials');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListServiceSpecificCredentials"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListServiceSpecificCredentials"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListServiceSpecificCredentials";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials'
http GET '{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_ListSigningCertificates
{{baseUrl}}/#Action=ListSigningCertificates
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListSigningCertificates" {:query-params {:Action ""
                                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListSigningCertificates',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListSigningCertificates',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListSigningCertificates');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListSigningCertificates',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListSigningCertificates');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListSigningCertificates');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListSigningCertificates"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListSigningCertificates"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListSigningCertificates";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates'
http GET '{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "Certificates": [
    {
      "CertificateBody": "-----BEGIN CERTIFICATE----------END CERTIFICATE-----",
      "CertificateId": "TA7SMP42TDN5Z26OBPJE7EXAMPLE",
      "Status": "Active",
      "UploadDate": "2013-06-06T21:40:08Z",
      "UserName": "Bob"
    }
  ]
}
GET GET_ListUserPolicies
{{baseUrl}}/#Action=ListUserPolicies
QUERY PARAMS
UserName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserPolicies");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListUserPolicies" {:query-params {:UserName ""
                                                                                   :Action ""
                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserPolicies"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserPolicies"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserPolicies");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserPolicies"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?UserName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserPolicies")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserPolicies"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserPolicies")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserPolicies")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserPolicies');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListUserPolicies',
  params: {UserName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserPolicies';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserPolicies',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserPolicies")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?UserName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListUserPolicies',
  qs: {UserName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListUserPolicies');

req.query({
  UserName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListUserPolicies',
  params: {UserName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserPolicies';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserPolicies"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserPolicies" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserPolicies",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserPolicies');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListUserPolicies');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'UserName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListUserPolicies');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'UserName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserPolicies' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserPolicies' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?UserName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListUserPolicies"

querystring = {"UserName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListUserPolicies"

queryString <- list(
  UserName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserPolicies")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['UserName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListUserPolicies";

    let querystring = [
        ("UserName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserPolicies'
http GET '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserPolicies'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserPolicies'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserPolicies")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_ListUserTags
{{baseUrl}}/#Action=ListUserTags
QUERY PARAMS
UserName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserTags");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListUserTags" {:query-params {:UserName ""
                                                                               :Action ""
                                                                               :Version ""}})
require "http/client"

url = "{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserTags"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserTags"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserTags");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserTags"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?UserName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserTags")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserTags"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserTags")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserTags")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserTags');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListUserTags',
  params: {UserName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserTags';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserTags',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserTags")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?UserName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListUserTags',
  qs: {UserName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListUserTags');

req.query({
  UserName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListUserTags',
  params: {UserName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserTags';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserTags"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserTags" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserTags",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserTags');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListUserTags');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'UserName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListUserTags');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'UserName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserTags' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserTags' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?UserName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListUserTags"

querystring = {"UserName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListUserTags"

queryString <- list(
  UserName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserTags")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['UserName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListUserTags";

    let querystring = [
        ("UserName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserTags'
http GET '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserTags'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserTags'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?UserName=&Action=&Version=#Action=ListUserTags")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "IsTruncated": false,
  "Tags": [
    {
      "Key": "Dept",
      "Value": "12345"
    },
    {
      "Key": "Team",
      "Value": "Accounting"
    }
  ]
}
GET GET_ListUsers
{{baseUrl}}/#Action=ListUsers
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListUsers");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListUsers" {:query-params {:Action ""
                                                                            :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListUsers"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?Action=&Version=#Action=ListUsers"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListUsers");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListUsers"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?Action=&Version=#Action=ListUsers")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListUsers"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListUsers")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=ListUsers")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?Action=&Version=#Action=ListUsers');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListUsers',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListUsers';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?Action=&Version=#Action=ListUsers',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListUsers")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListUsers',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListUsers');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListUsers',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListUsers';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?Action=&Version=#Action=ListUsers"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?Action=&Version=#Action=ListUsers" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListUsers",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?Action=&Version=#Action=ListUsers');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListUsers');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListUsers');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListUsers' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListUsers' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListUsers"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListUsers"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListUsers")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListUsers";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?Action=&Version=#Action=ListUsers'
http GET '{{baseUrl}}/?Action=&Version=#Action=ListUsers'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListUsers'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListUsers")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "Users": [
    {
      "Arn": "arn:aws:iam::123456789012:user/division_abc/subdivision_xyz/engineering/Juan",
      "CreateDate": "2012-09-05T19:38:48Z",
      "PasswordLastUsed": "2016-09-08T21:47:36Z",
      "Path": "/division_abc/subdivision_xyz/engineering/",
      "UserId": "AID2MAB8DPLSRHEXAMPLE",
      "UserName": "Juan"
    },
    {
      "Arn": "arn:aws:iam::123456789012:user/division_abc/subdivision_xyz/engineering/Anika",
      "CreateDate": "2014-04-09T15:43:45Z",
      "PasswordLastUsed": "2016-09-24T16:18:07Z",
      "Path": "/division_abc/subdivision_xyz/engineering/",
      "UserId": "AIDIODR4TAW7CSEXAMPLE",
      "UserName": "Anika"
    }
  ]
}
GET GET_ListVirtualMFADevices
{{baseUrl}}/#Action=ListVirtualMFADevices
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListVirtualMFADevices" {:query-params {:Action ""
                                                                                        :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListVirtualMFADevices',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListVirtualMFADevices',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ListVirtualMFADevices');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListVirtualMFADevices',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListVirtualMFADevices');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListVirtualMFADevices');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListVirtualMFADevices"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListVirtualMFADevices"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListVirtualMFADevices";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices'
http GET '{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "VirtualMFADevices": [
    {
      "SerialNumber": "arn:aws:iam::123456789012:mfa/ExampleMFADevice"
    },
    {
      "SerialNumber": "arn:aws:iam::123456789012:mfa/Juan"
    }
  ]
}
GET GET_PutGroupPolicy
{{baseUrl}}/#Action=PutGroupPolicy
QUERY PARAMS
GroupName
PolicyName
PolicyDocument
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?GroupName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutGroupPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=PutGroupPolicy" {:query-params {:GroupName ""
                                                                                 :PolicyName ""
                                                                                 :PolicyDocument ""
                                                                                 :Action ""
                                                                                 :Version ""}})
require "http/client"

url = "{{baseUrl}}/?GroupName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutGroupPolicy"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?GroupName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutGroupPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?GroupName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutGroupPolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?GroupName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutGroupPolicy"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?GroupName=&PolicyName=&PolicyDocument=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?GroupName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutGroupPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?GroupName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutGroupPolicy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?GroupName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutGroupPolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?GroupName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutGroupPolicy")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?GroupName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutGroupPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=PutGroupPolicy',
  params: {GroupName: '', PolicyName: '', PolicyDocument: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?GroupName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutGroupPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?GroupName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutGroupPolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?GroupName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutGroupPolicy")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?GroupName=&PolicyName=&PolicyDocument=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=PutGroupPolicy',
  qs: {GroupName: '', PolicyName: '', PolicyDocument: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=PutGroupPolicy');

req.query({
  GroupName: '',
  PolicyName: '',
  PolicyDocument: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=PutGroupPolicy',
  params: {GroupName: '', PolicyName: '', PolicyDocument: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?GroupName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutGroupPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?GroupName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutGroupPolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?GroupName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutGroupPolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?GroupName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutGroupPolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?GroupName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutGroupPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=PutGroupPolicy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'GroupName' => '',
  'PolicyName' => '',
  'PolicyDocument' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=PutGroupPolicy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'GroupName' => '',
  'PolicyName' => '',
  'PolicyDocument' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?GroupName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutGroupPolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?GroupName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutGroupPolicy' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?GroupName=&PolicyName=&PolicyDocument=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=PutGroupPolicy"

querystring = {"GroupName":"","PolicyName":"","PolicyDocument":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=PutGroupPolicy"

queryString <- list(
  GroupName = "",
  PolicyName = "",
  PolicyDocument = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?GroupName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutGroupPolicy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['GroupName'] = ''
  req.params['PolicyName'] = ''
  req.params['PolicyDocument'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=PutGroupPolicy";

    let querystring = [
        ("GroupName", ""),
        ("PolicyName", ""),
        ("PolicyDocument", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?GroupName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutGroupPolicy'
http GET '{{baseUrl}}/?GroupName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutGroupPolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?GroupName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutGroupPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?GroupName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutGroupPolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_PutRolePermissionsBoundary
{{baseUrl}}/#Action=PutRolePermissionsBoundary
QUERY PARAMS
RoleName
PermissionsBoundary
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?RoleName=&PermissionsBoundary=&Action=&Version=#Action=PutRolePermissionsBoundary");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=PutRolePermissionsBoundary" {:query-params {:RoleName ""
                                                                                             :PermissionsBoundary ""
                                                                                             :Action ""
                                                                                             :Version ""}})
require "http/client"

url = "{{baseUrl}}/?RoleName=&PermissionsBoundary=&Action=&Version=#Action=PutRolePermissionsBoundary"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?RoleName=&PermissionsBoundary=&Action=&Version=#Action=PutRolePermissionsBoundary"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?RoleName=&PermissionsBoundary=&Action=&Version=#Action=PutRolePermissionsBoundary");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?RoleName=&PermissionsBoundary=&Action=&Version=#Action=PutRolePermissionsBoundary"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?RoleName=&PermissionsBoundary=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?RoleName=&PermissionsBoundary=&Action=&Version=#Action=PutRolePermissionsBoundary")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?RoleName=&PermissionsBoundary=&Action=&Version=#Action=PutRolePermissionsBoundary"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?RoleName=&PermissionsBoundary=&Action=&Version=#Action=PutRolePermissionsBoundary")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?RoleName=&PermissionsBoundary=&Action=&Version=#Action=PutRolePermissionsBoundary")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?RoleName=&PermissionsBoundary=&Action=&Version=#Action=PutRolePermissionsBoundary');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=PutRolePermissionsBoundary',
  params: {RoleName: '', PermissionsBoundary: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?RoleName=&PermissionsBoundary=&Action=&Version=#Action=PutRolePermissionsBoundary';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?RoleName=&PermissionsBoundary=&Action=&Version=#Action=PutRolePermissionsBoundary',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?RoleName=&PermissionsBoundary=&Action=&Version=#Action=PutRolePermissionsBoundary")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?RoleName=&PermissionsBoundary=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=PutRolePermissionsBoundary',
  qs: {RoleName: '', PermissionsBoundary: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=PutRolePermissionsBoundary');

req.query({
  RoleName: '',
  PermissionsBoundary: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=PutRolePermissionsBoundary',
  params: {RoleName: '', PermissionsBoundary: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?RoleName=&PermissionsBoundary=&Action=&Version=#Action=PutRolePermissionsBoundary';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?RoleName=&PermissionsBoundary=&Action=&Version=#Action=PutRolePermissionsBoundary"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?RoleName=&PermissionsBoundary=&Action=&Version=#Action=PutRolePermissionsBoundary" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?RoleName=&PermissionsBoundary=&Action=&Version=#Action=PutRolePermissionsBoundary",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?RoleName=&PermissionsBoundary=&Action=&Version=#Action=PutRolePermissionsBoundary');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=PutRolePermissionsBoundary');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'RoleName' => '',
  'PermissionsBoundary' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=PutRolePermissionsBoundary');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'RoleName' => '',
  'PermissionsBoundary' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?RoleName=&PermissionsBoundary=&Action=&Version=#Action=PutRolePermissionsBoundary' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?RoleName=&PermissionsBoundary=&Action=&Version=#Action=PutRolePermissionsBoundary' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?RoleName=&PermissionsBoundary=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=PutRolePermissionsBoundary"

querystring = {"RoleName":"","PermissionsBoundary":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=PutRolePermissionsBoundary"

queryString <- list(
  RoleName = "",
  PermissionsBoundary = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?RoleName=&PermissionsBoundary=&Action=&Version=#Action=PutRolePermissionsBoundary")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['RoleName'] = ''
  req.params['PermissionsBoundary'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=PutRolePermissionsBoundary";

    let querystring = [
        ("RoleName", ""),
        ("PermissionsBoundary", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?RoleName=&PermissionsBoundary=&Action=&Version=#Action=PutRolePermissionsBoundary'
http GET '{{baseUrl}}/?RoleName=&PermissionsBoundary=&Action=&Version=#Action=PutRolePermissionsBoundary'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?RoleName=&PermissionsBoundary=&Action=&Version=#Action=PutRolePermissionsBoundary'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?RoleName=&PermissionsBoundary=&Action=&Version=#Action=PutRolePermissionsBoundary")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_PutRolePolicy
{{baseUrl}}/#Action=PutRolePolicy
QUERY PARAMS
RoleName
PolicyName
PolicyDocument
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?RoleName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutRolePolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=PutRolePolicy" {:query-params {:RoleName ""
                                                                                :PolicyName ""
                                                                                :PolicyDocument ""
                                                                                :Action ""
                                                                                :Version ""}})
require "http/client"

url = "{{baseUrl}}/?RoleName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutRolePolicy"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?RoleName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutRolePolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?RoleName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutRolePolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?RoleName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutRolePolicy"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?RoleName=&PolicyName=&PolicyDocument=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?RoleName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutRolePolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?RoleName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutRolePolicy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?RoleName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutRolePolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?RoleName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutRolePolicy")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?RoleName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutRolePolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=PutRolePolicy',
  params: {RoleName: '', PolicyName: '', PolicyDocument: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?RoleName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutRolePolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?RoleName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutRolePolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?RoleName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutRolePolicy")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?RoleName=&PolicyName=&PolicyDocument=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=PutRolePolicy',
  qs: {RoleName: '', PolicyName: '', PolicyDocument: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=PutRolePolicy');

req.query({
  RoleName: '',
  PolicyName: '',
  PolicyDocument: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=PutRolePolicy',
  params: {RoleName: '', PolicyName: '', PolicyDocument: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?RoleName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutRolePolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?RoleName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutRolePolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?RoleName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutRolePolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?RoleName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutRolePolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?RoleName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutRolePolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=PutRolePolicy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'RoleName' => '',
  'PolicyName' => '',
  'PolicyDocument' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=PutRolePolicy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'RoleName' => '',
  'PolicyName' => '',
  'PolicyDocument' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?RoleName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutRolePolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?RoleName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutRolePolicy' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?RoleName=&PolicyName=&PolicyDocument=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=PutRolePolicy"

querystring = {"RoleName":"","PolicyName":"","PolicyDocument":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=PutRolePolicy"

queryString <- list(
  RoleName = "",
  PolicyName = "",
  PolicyDocument = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?RoleName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutRolePolicy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['RoleName'] = ''
  req.params['PolicyName'] = ''
  req.params['PolicyDocument'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=PutRolePolicy";

    let querystring = [
        ("RoleName", ""),
        ("PolicyName", ""),
        ("PolicyDocument", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?RoleName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutRolePolicy'
http GET '{{baseUrl}}/?RoleName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutRolePolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?RoleName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutRolePolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?RoleName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutRolePolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_PutUserPermissionsBoundary
{{baseUrl}}/#Action=PutUserPermissionsBoundary
QUERY PARAMS
UserName
PermissionsBoundary
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?UserName=&PermissionsBoundary=&Action=&Version=#Action=PutUserPermissionsBoundary");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=PutUserPermissionsBoundary" {:query-params {:UserName ""
                                                                                             :PermissionsBoundary ""
                                                                                             :Action ""
                                                                                             :Version ""}})
require "http/client"

url = "{{baseUrl}}/?UserName=&PermissionsBoundary=&Action=&Version=#Action=PutUserPermissionsBoundary"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?UserName=&PermissionsBoundary=&Action=&Version=#Action=PutUserPermissionsBoundary"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?UserName=&PermissionsBoundary=&Action=&Version=#Action=PutUserPermissionsBoundary");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?UserName=&PermissionsBoundary=&Action=&Version=#Action=PutUserPermissionsBoundary"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?UserName=&PermissionsBoundary=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?UserName=&PermissionsBoundary=&Action=&Version=#Action=PutUserPermissionsBoundary")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?UserName=&PermissionsBoundary=&Action=&Version=#Action=PutUserPermissionsBoundary"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?UserName=&PermissionsBoundary=&Action=&Version=#Action=PutUserPermissionsBoundary")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?UserName=&PermissionsBoundary=&Action=&Version=#Action=PutUserPermissionsBoundary")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?UserName=&PermissionsBoundary=&Action=&Version=#Action=PutUserPermissionsBoundary');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=PutUserPermissionsBoundary',
  params: {UserName: '', PermissionsBoundary: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?UserName=&PermissionsBoundary=&Action=&Version=#Action=PutUserPermissionsBoundary';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?UserName=&PermissionsBoundary=&Action=&Version=#Action=PutUserPermissionsBoundary',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?UserName=&PermissionsBoundary=&Action=&Version=#Action=PutUserPermissionsBoundary")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?UserName=&PermissionsBoundary=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=PutUserPermissionsBoundary',
  qs: {UserName: '', PermissionsBoundary: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=PutUserPermissionsBoundary');

req.query({
  UserName: '',
  PermissionsBoundary: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=PutUserPermissionsBoundary',
  params: {UserName: '', PermissionsBoundary: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?UserName=&PermissionsBoundary=&Action=&Version=#Action=PutUserPermissionsBoundary';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?UserName=&PermissionsBoundary=&Action=&Version=#Action=PutUserPermissionsBoundary"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?UserName=&PermissionsBoundary=&Action=&Version=#Action=PutUserPermissionsBoundary" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?UserName=&PermissionsBoundary=&Action=&Version=#Action=PutUserPermissionsBoundary",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?UserName=&PermissionsBoundary=&Action=&Version=#Action=PutUserPermissionsBoundary');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=PutUserPermissionsBoundary');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'UserName' => '',
  'PermissionsBoundary' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=PutUserPermissionsBoundary');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'UserName' => '',
  'PermissionsBoundary' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?UserName=&PermissionsBoundary=&Action=&Version=#Action=PutUserPermissionsBoundary' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?UserName=&PermissionsBoundary=&Action=&Version=#Action=PutUserPermissionsBoundary' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?UserName=&PermissionsBoundary=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=PutUserPermissionsBoundary"

querystring = {"UserName":"","PermissionsBoundary":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=PutUserPermissionsBoundary"

queryString <- list(
  UserName = "",
  PermissionsBoundary = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?UserName=&PermissionsBoundary=&Action=&Version=#Action=PutUserPermissionsBoundary")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['UserName'] = ''
  req.params['PermissionsBoundary'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=PutUserPermissionsBoundary";

    let querystring = [
        ("UserName", ""),
        ("PermissionsBoundary", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?UserName=&PermissionsBoundary=&Action=&Version=#Action=PutUserPermissionsBoundary'
http GET '{{baseUrl}}/?UserName=&PermissionsBoundary=&Action=&Version=#Action=PutUserPermissionsBoundary'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?UserName=&PermissionsBoundary=&Action=&Version=#Action=PutUserPermissionsBoundary'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?UserName=&PermissionsBoundary=&Action=&Version=#Action=PutUserPermissionsBoundary")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_PutUserPolicy
{{baseUrl}}/#Action=PutUserPolicy
QUERY PARAMS
UserName
PolicyName
PolicyDocument
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?UserName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutUserPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=PutUserPolicy" {:query-params {:UserName ""
                                                                                :PolicyName ""
                                                                                :PolicyDocument ""
                                                                                :Action ""
                                                                                :Version ""}})
require "http/client"

url = "{{baseUrl}}/?UserName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutUserPolicy"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?UserName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutUserPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?UserName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutUserPolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?UserName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutUserPolicy"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?UserName=&PolicyName=&PolicyDocument=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?UserName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutUserPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?UserName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutUserPolicy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?UserName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutUserPolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?UserName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutUserPolicy")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?UserName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutUserPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=PutUserPolicy',
  params: {UserName: '', PolicyName: '', PolicyDocument: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?UserName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutUserPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?UserName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutUserPolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?UserName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutUserPolicy")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?UserName=&PolicyName=&PolicyDocument=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=PutUserPolicy',
  qs: {UserName: '', PolicyName: '', PolicyDocument: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=PutUserPolicy');

req.query({
  UserName: '',
  PolicyName: '',
  PolicyDocument: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=PutUserPolicy',
  params: {UserName: '', PolicyName: '', PolicyDocument: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?UserName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutUserPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?UserName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutUserPolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?UserName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutUserPolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?UserName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutUserPolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?UserName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutUserPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=PutUserPolicy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'UserName' => '',
  'PolicyName' => '',
  'PolicyDocument' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=PutUserPolicy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'UserName' => '',
  'PolicyName' => '',
  'PolicyDocument' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?UserName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutUserPolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?UserName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutUserPolicy' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?UserName=&PolicyName=&PolicyDocument=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=PutUserPolicy"

querystring = {"UserName":"","PolicyName":"","PolicyDocument":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=PutUserPolicy"

queryString <- list(
  UserName = "",
  PolicyName = "",
  PolicyDocument = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?UserName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutUserPolicy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['UserName'] = ''
  req.params['PolicyName'] = ''
  req.params['PolicyDocument'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=PutUserPolicy";

    let querystring = [
        ("UserName", ""),
        ("PolicyName", ""),
        ("PolicyDocument", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?UserName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutUserPolicy'
http GET '{{baseUrl}}/?UserName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutUserPolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?UserName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutUserPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?UserName=&PolicyName=&PolicyDocument=&Action=&Version=#Action=PutUserPolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_RemoveClientIDFromOpenIDConnectProvider
{{baseUrl}}/#Action=RemoveClientIDFromOpenIDConnectProvider
QUERY PARAMS
OpenIDConnectProviderArn
ClientID
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=RemoveClientIDFromOpenIDConnectProvider" {:query-params {:OpenIDConnectProviderArn ""
                                                                                                          :ClientID ""
                                                                                                          :Action ""
                                                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?OpenIDConnectProviderArn=&ClientID=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=RemoveClientIDFromOpenIDConnectProvider',
  params: {OpenIDConnectProviderArn: '', ClientID: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=RemoveClientIDFromOpenIDConnectProvider',
  qs: {OpenIDConnectProviderArn: '', ClientID: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=RemoveClientIDFromOpenIDConnectProvider');

req.query({
  OpenIDConnectProviderArn: '',
  ClientID: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=RemoveClientIDFromOpenIDConnectProvider',
  params: {OpenIDConnectProviderArn: '', ClientID: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=RemoveClientIDFromOpenIDConnectProvider');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'OpenIDConnectProviderArn' => '',
  'ClientID' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=RemoveClientIDFromOpenIDConnectProvider');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'OpenIDConnectProviderArn' => '',
  'ClientID' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=RemoveClientIDFromOpenIDConnectProvider"

querystring = {"OpenIDConnectProviderArn":"","ClientID":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=RemoveClientIDFromOpenIDConnectProvider"

queryString <- list(
  OpenIDConnectProviderArn = "",
  ClientID = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['OpenIDConnectProviderArn'] = ''
  req.params['ClientID'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=RemoveClientIDFromOpenIDConnectProvider";

    let querystring = [
        ("OpenIDConnectProviderArn", ""),
        ("ClientID", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider'
http GET '{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?OpenIDConnectProviderArn=&ClientID=&Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_RemoveRoleFromInstanceProfile
{{baseUrl}}/#Action=RemoveRoleFromInstanceProfile
QUERY PARAMS
InstanceProfileName
RoleName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=RemoveRoleFromInstanceProfile");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=RemoveRoleFromInstanceProfile" {:query-params {:InstanceProfileName ""
                                                                                                :RoleName ""
                                                                                                :Action ""
                                                                                                :Version ""}})
require "http/client"

url = "{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=RemoveRoleFromInstanceProfile"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=RemoveRoleFromInstanceProfile"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=RemoveRoleFromInstanceProfile");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=RemoveRoleFromInstanceProfile"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?InstanceProfileName=&RoleName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=RemoveRoleFromInstanceProfile")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=RemoveRoleFromInstanceProfile"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=RemoveRoleFromInstanceProfile")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=RemoveRoleFromInstanceProfile")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=RemoveRoleFromInstanceProfile');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=RemoveRoleFromInstanceProfile',
  params: {InstanceProfileName: '', RoleName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=RemoveRoleFromInstanceProfile';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=RemoveRoleFromInstanceProfile',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=RemoveRoleFromInstanceProfile")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?InstanceProfileName=&RoleName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=RemoveRoleFromInstanceProfile',
  qs: {InstanceProfileName: '', RoleName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=RemoveRoleFromInstanceProfile');

req.query({
  InstanceProfileName: '',
  RoleName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=RemoveRoleFromInstanceProfile',
  params: {InstanceProfileName: '', RoleName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=RemoveRoleFromInstanceProfile';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=RemoveRoleFromInstanceProfile"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=RemoveRoleFromInstanceProfile" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=RemoveRoleFromInstanceProfile",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=RemoveRoleFromInstanceProfile');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=RemoveRoleFromInstanceProfile');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'InstanceProfileName' => '',
  'RoleName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=RemoveRoleFromInstanceProfile');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'InstanceProfileName' => '',
  'RoleName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=RemoveRoleFromInstanceProfile' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=RemoveRoleFromInstanceProfile' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?InstanceProfileName=&RoleName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=RemoveRoleFromInstanceProfile"

querystring = {"InstanceProfileName":"","RoleName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=RemoveRoleFromInstanceProfile"

queryString <- list(
  InstanceProfileName = "",
  RoleName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=RemoveRoleFromInstanceProfile")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['InstanceProfileName'] = ''
  req.params['RoleName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=RemoveRoleFromInstanceProfile";

    let querystring = [
        ("InstanceProfileName", ""),
        ("RoleName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=RemoveRoleFromInstanceProfile'
http GET '{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=RemoveRoleFromInstanceProfile'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=RemoveRoleFromInstanceProfile'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?InstanceProfileName=&RoleName=&Action=&Version=#Action=RemoveRoleFromInstanceProfile")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_RemoveUserFromGroup
{{baseUrl}}/#Action=RemoveUserFromGroup
QUERY PARAMS
GroupName
UserName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=RemoveUserFromGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=RemoveUserFromGroup" {:query-params {:GroupName ""
                                                                                      :UserName ""
                                                                                      :Action ""
                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=RemoveUserFromGroup"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=RemoveUserFromGroup"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=RemoveUserFromGroup");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=RemoveUserFromGroup"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?GroupName=&UserName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=RemoveUserFromGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=RemoveUserFromGroup"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=RemoveUserFromGroup")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=RemoveUserFromGroup")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=RemoveUserFromGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=RemoveUserFromGroup',
  params: {GroupName: '', UserName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=RemoveUserFromGroup';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=RemoveUserFromGroup',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=RemoveUserFromGroup")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?GroupName=&UserName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=RemoveUserFromGroup',
  qs: {GroupName: '', UserName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=RemoveUserFromGroup');

req.query({
  GroupName: '',
  UserName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=RemoveUserFromGroup',
  params: {GroupName: '', UserName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=RemoveUserFromGroup';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=RemoveUserFromGroup"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=RemoveUserFromGroup" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=RemoveUserFromGroup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=RemoveUserFromGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=RemoveUserFromGroup');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'GroupName' => '',
  'UserName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=RemoveUserFromGroup');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'GroupName' => '',
  'UserName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=RemoveUserFromGroup' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=RemoveUserFromGroup' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?GroupName=&UserName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=RemoveUserFromGroup"

querystring = {"GroupName":"","UserName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=RemoveUserFromGroup"

queryString <- list(
  GroupName = "",
  UserName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=RemoveUserFromGroup")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['GroupName'] = ''
  req.params['UserName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=RemoveUserFromGroup";

    let querystring = [
        ("GroupName", ""),
        ("UserName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=RemoveUserFromGroup'
http GET '{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=RemoveUserFromGroup'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=RemoveUserFromGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?GroupName=&UserName=&Action=&Version=#Action=RemoveUserFromGroup")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_ResetServiceSpecificCredential
{{baseUrl}}/#Action=ResetServiceSpecificCredential
QUERY PARAMS
ServiceSpecificCredentialId
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=ResetServiceSpecificCredential");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ResetServiceSpecificCredential" {:query-params {:ServiceSpecificCredentialId ""
                                                                                                 :Action ""
                                                                                                 :Version ""}})
require "http/client"

url = "{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=ResetServiceSpecificCredential"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=ResetServiceSpecificCredential"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=ResetServiceSpecificCredential");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=ResetServiceSpecificCredential"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?ServiceSpecificCredentialId=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=ResetServiceSpecificCredential")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=ResetServiceSpecificCredential"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=ResetServiceSpecificCredential")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=ResetServiceSpecificCredential")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=ResetServiceSpecificCredential');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ResetServiceSpecificCredential',
  params: {ServiceSpecificCredentialId: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=ResetServiceSpecificCredential';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=ResetServiceSpecificCredential',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=ResetServiceSpecificCredential")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?ServiceSpecificCredentialId=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ResetServiceSpecificCredential',
  qs: {ServiceSpecificCredentialId: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ResetServiceSpecificCredential');

req.query({
  ServiceSpecificCredentialId: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ResetServiceSpecificCredential',
  params: {ServiceSpecificCredentialId: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=ResetServiceSpecificCredential';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=ResetServiceSpecificCredential"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=ResetServiceSpecificCredential" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=ResetServiceSpecificCredential",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=ResetServiceSpecificCredential');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ResetServiceSpecificCredential');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'ServiceSpecificCredentialId' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ResetServiceSpecificCredential');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'ServiceSpecificCredentialId' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=ResetServiceSpecificCredential' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=ResetServiceSpecificCredential' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?ServiceSpecificCredentialId=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ResetServiceSpecificCredential"

querystring = {"ServiceSpecificCredentialId":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ResetServiceSpecificCredential"

queryString <- list(
  ServiceSpecificCredentialId = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=ResetServiceSpecificCredential")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['ServiceSpecificCredentialId'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ResetServiceSpecificCredential";

    let querystring = [
        ("ServiceSpecificCredentialId", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=ResetServiceSpecificCredential'
http GET '{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=ResetServiceSpecificCredential'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=ResetServiceSpecificCredential'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?ServiceSpecificCredentialId=&Action=&Version=#Action=ResetServiceSpecificCredential")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_ResyncMFADevice
{{baseUrl}}/#Action=ResyncMFADevice
QUERY PARAMS
UserName
SerialNumber
AuthenticationCode1
AuthenticationCode2
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=ResyncMFADevice");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ResyncMFADevice" {:query-params {:UserName ""
                                                                                  :SerialNumber ""
                                                                                  :AuthenticationCode1 ""
                                                                                  :AuthenticationCode2 ""
                                                                                  :Action ""
                                                                                  :Version ""}})
require "http/client"

url = "{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=ResyncMFADevice"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=ResyncMFADevice"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=ResyncMFADevice");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=ResyncMFADevice"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=ResyncMFADevice")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=ResyncMFADevice"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=ResyncMFADevice")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=ResyncMFADevice")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=ResyncMFADevice');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ResyncMFADevice',
  params: {
    UserName: '',
    SerialNumber: '',
    AuthenticationCode1: '',
    AuthenticationCode2: '',
    Action: '',
    Version: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=ResyncMFADevice';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=ResyncMFADevice',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=ResyncMFADevice")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ResyncMFADevice',
  qs: {
    UserName: '',
    SerialNumber: '',
    AuthenticationCode1: '',
    AuthenticationCode2: '',
    Action: '',
    Version: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=ResyncMFADevice');

req.query({
  UserName: '',
  SerialNumber: '',
  AuthenticationCode1: '',
  AuthenticationCode2: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ResyncMFADevice',
  params: {
    UserName: '',
    SerialNumber: '',
    AuthenticationCode1: '',
    AuthenticationCode2: '',
    Action: '',
    Version: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=ResyncMFADevice';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=ResyncMFADevice"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=ResyncMFADevice" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=ResyncMFADevice",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=ResyncMFADevice');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ResyncMFADevice');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'UserName' => '',
  'SerialNumber' => '',
  'AuthenticationCode1' => '',
  'AuthenticationCode2' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ResyncMFADevice');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'UserName' => '',
  'SerialNumber' => '',
  'AuthenticationCode1' => '',
  'AuthenticationCode2' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=ResyncMFADevice' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=ResyncMFADevice' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ResyncMFADevice"

querystring = {"UserName":"","SerialNumber":"","AuthenticationCode1":"","AuthenticationCode2":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ResyncMFADevice"

queryString <- list(
  UserName = "",
  SerialNumber = "",
  AuthenticationCode1 = "",
  AuthenticationCode2 = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=ResyncMFADevice")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['UserName'] = ''
  req.params['SerialNumber'] = ''
  req.params['AuthenticationCode1'] = ''
  req.params['AuthenticationCode2'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ResyncMFADevice";

    let querystring = [
        ("UserName", ""),
        ("SerialNumber", ""),
        ("AuthenticationCode1", ""),
        ("AuthenticationCode2", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=ResyncMFADevice'
http GET '{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=ResyncMFADevice'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=ResyncMFADevice'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?UserName=&SerialNumber=&AuthenticationCode1=&AuthenticationCode2=&Action=&Version=#Action=ResyncMFADevice")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_SetDefaultPolicyVersion
{{baseUrl}}/#Action=SetDefaultPolicyVersion
QUERY PARAMS
PolicyArn
VersionId
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=SetDefaultPolicyVersion");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=SetDefaultPolicyVersion" {:query-params {:PolicyArn ""
                                                                                          :VersionId ""
                                                                                          :Action ""
                                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=SetDefaultPolicyVersion"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=SetDefaultPolicyVersion"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=SetDefaultPolicyVersion");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=SetDefaultPolicyVersion"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?PolicyArn=&VersionId=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=SetDefaultPolicyVersion")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=SetDefaultPolicyVersion"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=SetDefaultPolicyVersion")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=SetDefaultPolicyVersion")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=SetDefaultPolicyVersion');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=SetDefaultPolicyVersion',
  params: {PolicyArn: '', VersionId: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=SetDefaultPolicyVersion';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=SetDefaultPolicyVersion',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=SetDefaultPolicyVersion")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?PolicyArn=&VersionId=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=SetDefaultPolicyVersion',
  qs: {PolicyArn: '', VersionId: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=SetDefaultPolicyVersion');

req.query({
  PolicyArn: '',
  VersionId: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=SetDefaultPolicyVersion',
  params: {PolicyArn: '', VersionId: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=SetDefaultPolicyVersion';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=SetDefaultPolicyVersion"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=SetDefaultPolicyVersion" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=SetDefaultPolicyVersion",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=SetDefaultPolicyVersion');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=SetDefaultPolicyVersion');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'PolicyArn' => '',
  'VersionId' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=SetDefaultPolicyVersion');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'PolicyArn' => '',
  'VersionId' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=SetDefaultPolicyVersion' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=SetDefaultPolicyVersion' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?PolicyArn=&VersionId=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=SetDefaultPolicyVersion"

querystring = {"PolicyArn":"","VersionId":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=SetDefaultPolicyVersion"

queryString <- list(
  PolicyArn = "",
  VersionId = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=SetDefaultPolicyVersion")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['PolicyArn'] = ''
  req.params['VersionId'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=SetDefaultPolicyVersion";

    let querystring = [
        ("PolicyArn", ""),
        ("VersionId", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=SetDefaultPolicyVersion'
http GET '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=SetDefaultPolicyVersion'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=SetDefaultPolicyVersion'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?PolicyArn=&VersionId=&Action=&Version=#Action=SetDefaultPolicyVersion")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_SetSecurityTokenServicePreferences
{{baseUrl}}/#Action=SetSecurityTokenServicePreferences
QUERY PARAMS
GlobalEndpointTokenVersion
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?GlobalEndpointTokenVersion=&Action=&Version=#Action=SetSecurityTokenServicePreferences");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=SetSecurityTokenServicePreferences" {:query-params {:GlobalEndpointTokenVersion ""
                                                                                                     :Action ""
                                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?GlobalEndpointTokenVersion=&Action=&Version=#Action=SetSecurityTokenServicePreferences"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?GlobalEndpointTokenVersion=&Action=&Version=#Action=SetSecurityTokenServicePreferences"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?GlobalEndpointTokenVersion=&Action=&Version=#Action=SetSecurityTokenServicePreferences");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?GlobalEndpointTokenVersion=&Action=&Version=#Action=SetSecurityTokenServicePreferences"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?GlobalEndpointTokenVersion=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?GlobalEndpointTokenVersion=&Action=&Version=#Action=SetSecurityTokenServicePreferences")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?GlobalEndpointTokenVersion=&Action=&Version=#Action=SetSecurityTokenServicePreferences"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?GlobalEndpointTokenVersion=&Action=&Version=#Action=SetSecurityTokenServicePreferences")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?GlobalEndpointTokenVersion=&Action=&Version=#Action=SetSecurityTokenServicePreferences")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?GlobalEndpointTokenVersion=&Action=&Version=#Action=SetSecurityTokenServicePreferences');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=SetSecurityTokenServicePreferences',
  params: {GlobalEndpointTokenVersion: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?GlobalEndpointTokenVersion=&Action=&Version=#Action=SetSecurityTokenServicePreferences';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?GlobalEndpointTokenVersion=&Action=&Version=#Action=SetSecurityTokenServicePreferences',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?GlobalEndpointTokenVersion=&Action=&Version=#Action=SetSecurityTokenServicePreferences")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?GlobalEndpointTokenVersion=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=SetSecurityTokenServicePreferences',
  qs: {GlobalEndpointTokenVersion: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=SetSecurityTokenServicePreferences');

req.query({
  GlobalEndpointTokenVersion: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=SetSecurityTokenServicePreferences',
  params: {GlobalEndpointTokenVersion: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?GlobalEndpointTokenVersion=&Action=&Version=#Action=SetSecurityTokenServicePreferences';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?GlobalEndpointTokenVersion=&Action=&Version=#Action=SetSecurityTokenServicePreferences"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?GlobalEndpointTokenVersion=&Action=&Version=#Action=SetSecurityTokenServicePreferences" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?GlobalEndpointTokenVersion=&Action=&Version=#Action=SetSecurityTokenServicePreferences",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?GlobalEndpointTokenVersion=&Action=&Version=#Action=SetSecurityTokenServicePreferences');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=SetSecurityTokenServicePreferences');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'GlobalEndpointTokenVersion' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=SetSecurityTokenServicePreferences');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'GlobalEndpointTokenVersion' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?GlobalEndpointTokenVersion=&Action=&Version=#Action=SetSecurityTokenServicePreferences' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?GlobalEndpointTokenVersion=&Action=&Version=#Action=SetSecurityTokenServicePreferences' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?GlobalEndpointTokenVersion=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=SetSecurityTokenServicePreferences"

querystring = {"GlobalEndpointTokenVersion":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=SetSecurityTokenServicePreferences"

queryString <- list(
  GlobalEndpointTokenVersion = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?GlobalEndpointTokenVersion=&Action=&Version=#Action=SetSecurityTokenServicePreferences")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['GlobalEndpointTokenVersion'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=SetSecurityTokenServicePreferences";

    let querystring = [
        ("GlobalEndpointTokenVersion", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?GlobalEndpointTokenVersion=&Action=&Version=#Action=SetSecurityTokenServicePreferences'
http GET '{{baseUrl}}/?GlobalEndpointTokenVersion=&Action=&Version=#Action=SetSecurityTokenServicePreferences'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?GlobalEndpointTokenVersion=&Action=&Version=#Action=SetSecurityTokenServicePreferences'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?GlobalEndpointTokenVersion=&Action=&Version=#Action=SetSecurityTokenServicePreferences")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_SimulateCustomPolicy
{{baseUrl}}/#Action=SimulateCustomPolicy
QUERY PARAMS
PolicyInputList
ActionNames
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?PolicyInputList=&ActionNames=&Action=&Version=#Action=SimulateCustomPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=SimulateCustomPolicy" {:query-params {:PolicyInputList ""
                                                                                       :ActionNames ""
                                                                                       :Action ""
                                                                                       :Version ""}})
require "http/client"

url = "{{baseUrl}}/?PolicyInputList=&ActionNames=&Action=&Version=#Action=SimulateCustomPolicy"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?PolicyInputList=&ActionNames=&Action=&Version=#Action=SimulateCustomPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?PolicyInputList=&ActionNames=&Action=&Version=#Action=SimulateCustomPolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?PolicyInputList=&ActionNames=&Action=&Version=#Action=SimulateCustomPolicy"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?PolicyInputList=&ActionNames=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?PolicyInputList=&ActionNames=&Action=&Version=#Action=SimulateCustomPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?PolicyInputList=&ActionNames=&Action=&Version=#Action=SimulateCustomPolicy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?PolicyInputList=&ActionNames=&Action=&Version=#Action=SimulateCustomPolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?PolicyInputList=&ActionNames=&Action=&Version=#Action=SimulateCustomPolicy")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?PolicyInputList=&ActionNames=&Action=&Version=#Action=SimulateCustomPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=SimulateCustomPolicy',
  params: {PolicyInputList: '', ActionNames: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?PolicyInputList=&ActionNames=&Action=&Version=#Action=SimulateCustomPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?PolicyInputList=&ActionNames=&Action=&Version=#Action=SimulateCustomPolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?PolicyInputList=&ActionNames=&Action=&Version=#Action=SimulateCustomPolicy")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?PolicyInputList=&ActionNames=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=SimulateCustomPolicy',
  qs: {PolicyInputList: '', ActionNames: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=SimulateCustomPolicy');

req.query({
  PolicyInputList: '',
  ActionNames: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=SimulateCustomPolicy',
  params: {PolicyInputList: '', ActionNames: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?PolicyInputList=&ActionNames=&Action=&Version=#Action=SimulateCustomPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?PolicyInputList=&ActionNames=&Action=&Version=#Action=SimulateCustomPolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?PolicyInputList=&ActionNames=&Action=&Version=#Action=SimulateCustomPolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?PolicyInputList=&ActionNames=&Action=&Version=#Action=SimulateCustomPolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?PolicyInputList=&ActionNames=&Action=&Version=#Action=SimulateCustomPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=SimulateCustomPolicy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'PolicyInputList' => '',
  'ActionNames' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=SimulateCustomPolicy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'PolicyInputList' => '',
  'ActionNames' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?PolicyInputList=&ActionNames=&Action=&Version=#Action=SimulateCustomPolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?PolicyInputList=&ActionNames=&Action=&Version=#Action=SimulateCustomPolicy' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?PolicyInputList=&ActionNames=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=SimulateCustomPolicy"

querystring = {"PolicyInputList":"","ActionNames":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=SimulateCustomPolicy"

queryString <- list(
  PolicyInputList = "",
  ActionNames = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?PolicyInputList=&ActionNames=&Action=&Version=#Action=SimulateCustomPolicy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['PolicyInputList'] = ''
  req.params['ActionNames'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=SimulateCustomPolicy";

    let querystring = [
        ("PolicyInputList", ""),
        ("ActionNames", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?PolicyInputList=&ActionNames=&Action=&Version=#Action=SimulateCustomPolicy'
http GET '{{baseUrl}}/?PolicyInputList=&ActionNames=&Action=&Version=#Action=SimulateCustomPolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?PolicyInputList=&ActionNames=&Action=&Version=#Action=SimulateCustomPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?PolicyInputList=&ActionNames=&Action=&Version=#Action=SimulateCustomPolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_SimulatePrincipalPolicy
{{baseUrl}}/#Action=SimulatePrincipalPolicy
QUERY PARAMS
PolicySourceArn
ActionNames
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?PolicySourceArn=&ActionNames=&Action=&Version=#Action=SimulatePrincipalPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=SimulatePrincipalPolicy" {:query-params {:PolicySourceArn ""
                                                                                          :ActionNames ""
                                                                                          :Action ""
                                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?PolicySourceArn=&ActionNames=&Action=&Version=#Action=SimulatePrincipalPolicy"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?PolicySourceArn=&ActionNames=&Action=&Version=#Action=SimulatePrincipalPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?PolicySourceArn=&ActionNames=&Action=&Version=#Action=SimulatePrincipalPolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?PolicySourceArn=&ActionNames=&Action=&Version=#Action=SimulatePrincipalPolicy"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?PolicySourceArn=&ActionNames=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?PolicySourceArn=&ActionNames=&Action=&Version=#Action=SimulatePrincipalPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?PolicySourceArn=&ActionNames=&Action=&Version=#Action=SimulatePrincipalPolicy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?PolicySourceArn=&ActionNames=&Action=&Version=#Action=SimulatePrincipalPolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?PolicySourceArn=&ActionNames=&Action=&Version=#Action=SimulatePrincipalPolicy")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?PolicySourceArn=&ActionNames=&Action=&Version=#Action=SimulatePrincipalPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=SimulatePrincipalPolicy',
  params: {PolicySourceArn: '', ActionNames: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?PolicySourceArn=&ActionNames=&Action=&Version=#Action=SimulatePrincipalPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?PolicySourceArn=&ActionNames=&Action=&Version=#Action=SimulatePrincipalPolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?PolicySourceArn=&ActionNames=&Action=&Version=#Action=SimulatePrincipalPolicy")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?PolicySourceArn=&ActionNames=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=SimulatePrincipalPolicy',
  qs: {PolicySourceArn: '', ActionNames: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=SimulatePrincipalPolicy');

req.query({
  PolicySourceArn: '',
  ActionNames: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=SimulatePrincipalPolicy',
  params: {PolicySourceArn: '', ActionNames: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?PolicySourceArn=&ActionNames=&Action=&Version=#Action=SimulatePrincipalPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?PolicySourceArn=&ActionNames=&Action=&Version=#Action=SimulatePrincipalPolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?PolicySourceArn=&ActionNames=&Action=&Version=#Action=SimulatePrincipalPolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?PolicySourceArn=&ActionNames=&Action=&Version=#Action=SimulatePrincipalPolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?PolicySourceArn=&ActionNames=&Action=&Version=#Action=SimulatePrincipalPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=SimulatePrincipalPolicy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'PolicySourceArn' => '',
  'ActionNames' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=SimulatePrincipalPolicy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'PolicySourceArn' => '',
  'ActionNames' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?PolicySourceArn=&ActionNames=&Action=&Version=#Action=SimulatePrincipalPolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?PolicySourceArn=&ActionNames=&Action=&Version=#Action=SimulatePrincipalPolicy' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?PolicySourceArn=&ActionNames=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=SimulatePrincipalPolicy"

querystring = {"PolicySourceArn":"","ActionNames":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=SimulatePrincipalPolicy"

queryString <- list(
  PolicySourceArn = "",
  ActionNames = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?PolicySourceArn=&ActionNames=&Action=&Version=#Action=SimulatePrincipalPolicy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['PolicySourceArn'] = ''
  req.params['ActionNames'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=SimulatePrincipalPolicy";

    let querystring = [
        ("PolicySourceArn", ""),
        ("ActionNames", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?PolicySourceArn=&ActionNames=&Action=&Version=#Action=SimulatePrincipalPolicy'
http GET '{{baseUrl}}/?PolicySourceArn=&ActionNames=&Action=&Version=#Action=SimulatePrincipalPolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?PolicySourceArn=&ActionNames=&Action=&Version=#Action=SimulatePrincipalPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?PolicySourceArn=&ActionNames=&Action=&Version=#Action=SimulatePrincipalPolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_TagInstanceProfile
{{baseUrl}}/#Action=TagInstanceProfile
QUERY PARAMS
InstanceProfileName
Tags
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?InstanceProfileName=&Tags=&Action=&Version=#Action=TagInstanceProfile");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=TagInstanceProfile" {:query-params {:InstanceProfileName ""
                                                                                     :Tags ""
                                                                                     :Action ""
                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?InstanceProfileName=&Tags=&Action=&Version=#Action=TagInstanceProfile"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?InstanceProfileName=&Tags=&Action=&Version=#Action=TagInstanceProfile"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?InstanceProfileName=&Tags=&Action=&Version=#Action=TagInstanceProfile");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?InstanceProfileName=&Tags=&Action=&Version=#Action=TagInstanceProfile"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?InstanceProfileName=&Tags=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?InstanceProfileName=&Tags=&Action=&Version=#Action=TagInstanceProfile")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?InstanceProfileName=&Tags=&Action=&Version=#Action=TagInstanceProfile"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?InstanceProfileName=&Tags=&Action=&Version=#Action=TagInstanceProfile")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?InstanceProfileName=&Tags=&Action=&Version=#Action=TagInstanceProfile")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?InstanceProfileName=&Tags=&Action=&Version=#Action=TagInstanceProfile');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=TagInstanceProfile',
  params: {InstanceProfileName: '', Tags: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?InstanceProfileName=&Tags=&Action=&Version=#Action=TagInstanceProfile';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?InstanceProfileName=&Tags=&Action=&Version=#Action=TagInstanceProfile',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?InstanceProfileName=&Tags=&Action=&Version=#Action=TagInstanceProfile")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?InstanceProfileName=&Tags=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=TagInstanceProfile',
  qs: {InstanceProfileName: '', Tags: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=TagInstanceProfile');

req.query({
  InstanceProfileName: '',
  Tags: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=TagInstanceProfile',
  params: {InstanceProfileName: '', Tags: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?InstanceProfileName=&Tags=&Action=&Version=#Action=TagInstanceProfile';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?InstanceProfileName=&Tags=&Action=&Version=#Action=TagInstanceProfile"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?InstanceProfileName=&Tags=&Action=&Version=#Action=TagInstanceProfile" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?InstanceProfileName=&Tags=&Action=&Version=#Action=TagInstanceProfile",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?InstanceProfileName=&Tags=&Action=&Version=#Action=TagInstanceProfile');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=TagInstanceProfile');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'InstanceProfileName' => '',
  'Tags' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=TagInstanceProfile');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'InstanceProfileName' => '',
  'Tags' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?InstanceProfileName=&Tags=&Action=&Version=#Action=TagInstanceProfile' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?InstanceProfileName=&Tags=&Action=&Version=#Action=TagInstanceProfile' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?InstanceProfileName=&Tags=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=TagInstanceProfile"

querystring = {"InstanceProfileName":"","Tags":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=TagInstanceProfile"

queryString <- list(
  InstanceProfileName = "",
  Tags = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?InstanceProfileName=&Tags=&Action=&Version=#Action=TagInstanceProfile")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['InstanceProfileName'] = ''
  req.params['Tags'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=TagInstanceProfile";

    let querystring = [
        ("InstanceProfileName", ""),
        ("Tags", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?InstanceProfileName=&Tags=&Action=&Version=#Action=TagInstanceProfile'
http GET '{{baseUrl}}/?InstanceProfileName=&Tags=&Action=&Version=#Action=TagInstanceProfile'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?InstanceProfileName=&Tags=&Action=&Version=#Action=TagInstanceProfile'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?InstanceProfileName=&Tags=&Action=&Version=#Action=TagInstanceProfile")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_TagMFADevice
{{baseUrl}}/#Action=TagMFADevice
QUERY PARAMS
SerialNumber
Tags
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?SerialNumber=&Tags=&Action=&Version=#Action=TagMFADevice");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=TagMFADevice" {:query-params {:SerialNumber ""
                                                                               :Tags ""
                                                                               :Action ""
                                                                               :Version ""}})
require "http/client"

url = "{{baseUrl}}/?SerialNumber=&Tags=&Action=&Version=#Action=TagMFADevice"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?SerialNumber=&Tags=&Action=&Version=#Action=TagMFADevice"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?SerialNumber=&Tags=&Action=&Version=#Action=TagMFADevice");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?SerialNumber=&Tags=&Action=&Version=#Action=TagMFADevice"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?SerialNumber=&Tags=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?SerialNumber=&Tags=&Action=&Version=#Action=TagMFADevice")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?SerialNumber=&Tags=&Action=&Version=#Action=TagMFADevice"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?SerialNumber=&Tags=&Action=&Version=#Action=TagMFADevice")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?SerialNumber=&Tags=&Action=&Version=#Action=TagMFADevice")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?SerialNumber=&Tags=&Action=&Version=#Action=TagMFADevice');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=TagMFADevice',
  params: {SerialNumber: '', Tags: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?SerialNumber=&Tags=&Action=&Version=#Action=TagMFADevice';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?SerialNumber=&Tags=&Action=&Version=#Action=TagMFADevice',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?SerialNumber=&Tags=&Action=&Version=#Action=TagMFADevice")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?SerialNumber=&Tags=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=TagMFADevice',
  qs: {SerialNumber: '', Tags: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=TagMFADevice');

req.query({
  SerialNumber: '',
  Tags: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=TagMFADevice',
  params: {SerialNumber: '', Tags: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?SerialNumber=&Tags=&Action=&Version=#Action=TagMFADevice';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?SerialNumber=&Tags=&Action=&Version=#Action=TagMFADevice"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?SerialNumber=&Tags=&Action=&Version=#Action=TagMFADevice" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?SerialNumber=&Tags=&Action=&Version=#Action=TagMFADevice",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?SerialNumber=&Tags=&Action=&Version=#Action=TagMFADevice');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=TagMFADevice');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'SerialNumber' => '',
  'Tags' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=TagMFADevice');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'SerialNumber' => '',
  'Tags' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?SerialNumber=&Tags=&Action=&Version=#Action=TagMFADevice' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?SerialNumber=&Tags=&Action=&Version=#Action=TagMFADevice' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?SerialNumber=&Tags=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=TagMFADevice"

querystring = {"SerialNumber":"","Tags":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=TagMFADevice"

queryString <- list(
  SerialNumber = "",
  Tags = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?SerialNumber=&Tags=&Action=&Version=#Action=TagMFADevice")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['SerialNumber'] = ''
  req.params['Tags'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=TagMFADevice";

    let querystring = [
        ("SerialNumber", ""),
        ("Tags", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?SerialNumber=&Tags=&Action=&Version=#Action=TagMFADevice'
http GET '{{baseUrl}}/?SerialNumber=&Tags=&Action=&Version=#Action=TagMFADevice'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?SerialNumber=&Tags=&Action=&Version=#Action=TagMFADevice'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?SerialNumber=&Tags=&Action=&Version=#Action=TagMFADevice")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_TagOpenIDConnectProvider
{{baseUrl}}/#Action=TagOpenIDConnectProvider
QUERY PARAMS
OpenIDConnectProviderArn
Tags
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?OpenIDConnectProviderArn=&Tags=&Action=&Version=#Action=TagOpenIDConnectProvider");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=TagOpenIDConnectProvider" {:query-params {:OpenIDConnectProviderArn ""
                                                                                           :Tags ""
                                                                                           :Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?OpenIDConnectProviderArn=&Tags=&Action=&Version=#Action=TagOpenIDConnectProvider"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?OpenIDConnectProviderArn=&Tags=&Action=&Version=#Action=TagOpenIDConnectProvider"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?OpenIDConnectProviderArn=&Tags=&Action=&Version=#Action=TagOpenIDConnectProvider");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?OpenIDConnectProviderArn=&Tags=&Action=&Version=#Action=TagOpenIDConnectProvider"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?OpenIDConnectProviderArn=&Tags=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?OpenIDConnectProviderArn=&Tags=&Action=&Version=#Action=TagOpenIDConnectProvider")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?OpenIDConnectProviderArn=&Tags=&Action=&Version=#Action=TagOpenIDConnectProvider"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?OpenIDConnectProviderArn=&Tags=&Action=&Version=#Action=TagOpenIDConnectProvider")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?OpenIDConnectProviderArn=&Tags=&Action=&Version=#Action=TagOpenIDConnectProvider")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?OpenIDConnectProviderArn=&Tags=&Action=&Version=#Action=TagOpenIDConnectProvider');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=TagOpenIDConnectProvider',
  params: {OpenIDConnectProviderArn: '', Tags: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?OpenIDConnectProviderArn=&Tags=&Action=&Version=#Action=TagOpenIDConnectProvider';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?OpenIDConnectProviderArn=&Tags=&Action=&Version=#Action=TagOpenIDConnectProvider',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?OpenIDConnectProviderArn=&Tags=&Action=&Version=#Action=TagOpenIDConnectProvider")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?OpenIDConnectProviderArn=&Tags=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=TagOpenIDConnectProvider',
  qs: {OpenIDConnectProviderArn: '', Tags: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=TagOpenIDConnectProvider');

req.query({
  OpenIDConnectProviderArn: '',
  Tags: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=TagOpenIDConnectProvider',
  params: {OpenIDConnectProviderArn: '', Tags: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?OpenIDConnectProviderArn=&Tags=&Action=&Version=#Action=TagOpenIDConnectProvider';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?OpenIDConnectProviderArn=&Tags=&Action=&Version=#Action=TagOpenIDConnectProvider"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?OpenIDConnectProviderArn=&Tags=&Action=&Version=#Action=TagOpenIDConnectProvider" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?OpenIDConnectProviderArn=&Tags=&Action=&Version=#Action=TagOpenIDConnectProvider",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?OpenIDConnectProviderArn=&Tags=&Action=&Version=#Action=TagOpenIDConnectProvider');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=TagOpenIDConnectProvider');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'OpenIDConnectProviderArn' => '',
  'Tags' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=TagOpenIDConnectProvider');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'OpenIDConnectProviderArn' => '',
  'Tags' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?OpenIDConnectProviderArn=&Tags=&Action=&Version=#Action=TagOpenIDConnectProvider' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?OpenIDConnectProviderArn=&Tags=&Action=&Version=#Action=TagOpenIDConnectProvider' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?OpenIDConnectProviderArn=&Tags=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=TagOpenIDConnectProvider"

querystring = {"OpenIDConnectProviderArn":"","Tags":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=TagOpenIDConnectProvider"

queryString <- list(
  OpenIDConnectProviderArn = "",
  Tags = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?OpenIDConnectProviderArn=&Tags=&Action=&Version=#Action=TagOpenIDConnectProvider")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['OpenIDConnectProviderArn'] = ''
  req.params['Tags'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=TagOpenIDConnectProvider";

    let querystring = [
        ("OpenIDConnectProviderArn", ""),
        ("Tags", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?OpenIDConnectProviderArn=&Tags=&Action=&Version=#Action=TagOpenIDConnectProvider'
http GET '{{baseUrl}}/?OpenIDConnectProviderArn=&Tags=&Action=&Version=#Action=TagOpenIDConnectProvider'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?OpenIDConnectProviderArn=&Tags=&Action=&Version=#Action=TagOpenIDConnectProvider'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?OpenIDConnectProviderArn=&Tags=&Action=&Version=#Action=TagOpenIDConnectProvider")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_TagPolicy
{{baseUrl}}/#Action=TagPolicy
QUERY PARAMS
PolicyArn
Tags
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?PolicyArn=&Tags=&Action=&Version=#Action=TagPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=TagPolicy" {:query-params {:PolicyArn ""
                                                                            :Tags ""
                                                                            :Action ""
                                                                            :Version ""}})
require "http/client"

url = "{{baseUrl}}/?PolicyArn=&Tags=&Action=&Version=#Action=TagPolicy"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?PolicyArn=&Tags=&Action=&Version=#Action=TagPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?PolicyArn=&Tags=&Action=&Version=#Action=TagPolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?PolicyArn=&Tags=&Action=&Version=#Action=TagPolicy"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?PolicyArn=&Tags=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?PolicyArn=&Tags=&Action=&Version=#Action=TagPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?PolicyArn=&Tags=&Action=&Version=#Action=TagPolicy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?PolicyArn=&Tags=&Action=&Version=#Action=TagPolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?PolicyArn=&Tags=&Action=&Version=#Action=TagPolicy")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?PolicyArn=&Tags=&Action=&Version=#Action=TagPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=TagPolicy',
  params: {PolicyArn: '', Tags: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?PolicyArn=&Tags=&Action=&Version=#Action=TagPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?PolicyArn=&Tags=&Action=&Version=#Action=TagPolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?PolicyArn=&Tags=&Action=&Version=#Action=TagPolicy")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?PolicyArn=&Tags=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=TagPolicy',
  qs: {PolicyArn: '', Tags: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=TagPolicy');

req.query({
  PolicyArn: '',
  Tags: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=TagPolicy',
  params: {PolicyArn: '', Tags: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?PolicyArn=&Tags=&Action=&Version=#Action=TagPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?PolicyArn=&Tags=&Action=&Version=#Action=TagPolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?PolicyArn=&Tags=&Action=&Version=#Action=TagPolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?PolicyArn=&Tags=&Action=&Version=#Action=TagPolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?PolicyArn=&Tags=&Action=&Version=#Action=TagPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=TagPolicy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'PolicyArn' => '',
  'Tags' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=TagPolicy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'PolicyArn' => '',
  'Tags' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?PolicyArn=&Tags=&Action=&Version=#Action=TagPolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?PolicyArn=&Tags=&Action=&Version=#Action=TagPolicy' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?PolicyArn=&Tags=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=TagPolicy"

querystring = {"PolicyArn":"","Tags":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=TagPolicy"

queryString <- list(
  PolicyArn = "",
  Tags = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?PolicyArn=&Tags=&Action=&Version=#Action=TagPolicy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['PolicyArn'] = ''
  req.params['Tags'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=TagPolicy";

    let querystring = [
        ("PolicyArn", ""),
        ("Tags", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?PolicyArn=&Tags=&Action=&Version=#Action=TagPolicy'
http GET '{{baseUrl}}/?PolicyArn=&Tags=&Action=&Version=#Action=TagPolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?PolicyArn=&Tags=&Action=&Version=#Action=TagPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?PolicyArn=&Tags=&Action=&Version=#Action=TagPolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_TagRole
{{baseUrl}}/#Action=TagRole
QUERY PARAMS
RoleName
Tags
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?RoleName=&Tags=&Action=&Version=#Action=TagRole");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=TagRole" {:query-params {:RoleName ""
                                                                          :Tags ""
                                                                          :Action ""
                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?RoleName=&Tags=&Action=&Version=#Action=TagRole"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?RoleName=&Tags=&Action=&Version=#Action=TagRole"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?RoleName=&Tags=&Action=&Version=#Action=TagRole");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?RoleName=&Tags=&Action=&Version=#Action=TagRole"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?RoleName=&Tags=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?RoleName=&Tags=&Action=&Version=#Action=TagRole")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?RoleName=&Tags=&Action=&Version=#Action=TagRole"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?RoleName=&Tags=&Action=&Version=#Action=TagRole")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?RoleName=&Tags=&Action=&Version=#Action=TagRole")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?RoleName=&Tags=&Action=&Version=#Action=TagRole');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=TagRole',
  params: {RoleName: '', Tags: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?RoleName=&Tags=&Action=&Version=#Action=TagRole';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?RoleName=&Tags=&Action=&Version=#Action=TagRole',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?RoleName=&Tags=&Action=&Version=#Action=TagRole")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?RoleName=&Tags=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=TagRole',
  qs: {RoleName: '', Tags: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=TagRole');

req.query({
  RoleName: '',
  Tags: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=TagRole',
  params: {RoleName: '', Tags: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?RoleName=&Tags=&Action=&Version=#Action=TagRole';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?RoleName=&Tags=&Action=&Version=#Action=TagRole"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?RoleName=&Tags=&Action=&Version=#Action=TagRole" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?RoleName=&Tags=&Action=&Version=#Action=TagRole",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?RoleName=&Tags=&Action=&Version=#Action=TagRole');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=TagRole');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'RoleName' => '',
  'Tags' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=TagRole');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'RoleName' => '',
  'Tags' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?RoleName=&Tags=&Action=&Version=#Action=TagRole' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?RoleName=&Tags=&Action=&Version=#Action=TagRole' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?RoleName=&Tags=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=TagRole"

querystring = {"RoleName":"","Tags":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=TagRole"

queryString <- list(
  RoleName = "",
  Tags = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?RoleName=&Tags=&Action=&Version=#Action=TagRole")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['RoleName'] = ''
  req.params['Tags'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=TagRole";

    let querystring = [
        ("RoleName", ""),
        ("Tags", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?RoleName=&Tags=&Action=&Version=#Action=TagRole'
http GET '{{baseUrl}}/?RoleName=&Tags=&Action=&Version=#Action=TagRole'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?RoleName=&Tags=&Action=&Version=#Action=TagRole'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?RoleName=&Tags=&Action=&Version=#Action=TagRole")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_TagSAMLProvider
{{baseUrl}}/#Action=TagSAMLProvider
QUERY PARAMS
SAMLProviderArn
Tags
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?SAMLProviderArn=&Tags=&Action=&Version=#Action=TagSAMLProvider");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=TagSAMLProvider" {:query-params {:SAMLProviderArn ""
                                                                                  :Tags ""
                                                                                  :Action ""
                                                                                  :Version ""}})
require "http/client"

url = "{{baseUrl}}/?SAMLProviderArn=&Tags=&Action=&Version=#Action=TagSAMLProvider"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?SAMLProviderArn=&Tags=&Action=&Version=#Action=TagSAMLProvider"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?SAMLProviderArn=&Tags=&Action=&Version=#Action=TagSAMLProvider");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?SAMLProviderArn=&Tags=&Action=&Version=#Action=TagSAMLProvider"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?SAMLProviderArn=&Tags=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?SAMLProviderArn=&Tags=&Action=&Version=#Action=TagSAMLProvider")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?SAMLProviderArn=&Tags=&Action=&Version=#Action=TagSAMLProvider"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?SAMLProviderArn=&Tags=&Action=&Version=#Action=TagSAMLProvider")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?SAMLProviderArn=&Tags=&Action=&Version=#Action=TagSAMLProvider")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?SAMLProviderArn=&Tags=&Action=&Version=#Action=TagSAMLProvider');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=TagSAMLProvider',
  params: {SAMLProviderArn: '', Tags: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?SAMLProviderArn=&Tags=&Action=&Version=#Action=TagSAMLProvider';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?SAMLProviderArn=&Tags=&Action=&Version=#Action=TagSAMLProvider',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?SAMLProviderArn=&Tags=&Action=&Version=#Action=TagSAMLProvider")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?SAMLProviderArn=&Tags=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=TagSAMLProvider',
  qs: {SAMLProviderArn: '', Tags: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=TagSAMLProvider');

req.query({
  SAMLProviderArn: '',
  Tags: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=TagSAMLProvider',
  params: {SAMLProviderArn: '', Tags: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?SAMLProviderArn=&Tags=&Action=&Version=#Action=TagSAMLProvider';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?SAMLProviderArn=&Tags=&Action=&Version=#Action=TagSAMLProvider"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?SAMLProviderArn=&Tags=&Action=&Version=#Action=TagSAMLProvider" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?SAMLProviderArn=&Tags=&Action=&Version=#Action=TagSAMLProvider",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?SAMLProviderArn=&Tags=&Action=&Version=#Action=TagSAMLProvider');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=TagSAMLProvider');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'SAMLProviderArn' => '',
  'Tags' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=TagSAMLProvider');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'SAMLProviderArn' => '',
  'Tags' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?SAMLProviderArn=&Tags=&Action=&Version=#Action=TagSAMLProvider' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?SAMLProviderArn=&Tags=&Action=&Version=#Action=TagSAMLProvider' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?SAMLProviderArn=&Tags=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=TagSAMLProvider"

querystring = {"SAMLProviderArn":"","Tags":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=TagSAMLProvider"

queryString <- list(
  SAMLProviderArn = "",
  Tags = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?SAMLProviderArn=&Tags=&Action=&Version=#Action=TagSAMLProvider")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['SAMLProviderArn'] = ''
  req.params['Tags'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=TagSAMLProvider";

    let querystring = [
        ("SAMLProviderArn", ""),
        ("Tags", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?SAMLProviderArn=&Tags=&Action=&Version=#Action=TagSAMLProvider'
http GET '{{baseUrl}}/?SAMLProviderArn=&Tags=&Action=&Version=#Action=TagSAMLProvider'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?SAMLProviderArn=&Tags=&Action=&Version=#Action=TagSAMLProvider'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?SAMLProviderArn=&Tags=&Action=&Version=#Action=TagSAMLProvider")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_TagServerCertificate
{{baseUrl}}/#Action=TagServerCertificate
QUERY PARAMS
ServerCertificateName
Tags
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?ServerCertificateName=&Tags=&Action=&Version=#Action=TagServerCertificate");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=TagServerCertificate" {:query-params {:ServerCertificateName ""
                                                                                       :Tags ""
                                                                                       :Action ""
                                                                                       :Version ""}})
require "http/client"

url = "{{baseUrl}}/?ServerCertificateName=&Tags=&Action=&Version=#Action=TagServerCertificate"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?ServerCertificateName=&Tags=&Action=&Version=#Action=TagServerCertificate"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?ServerCertificateName=&Tags=&Action=&Version=#Action=TagServerCertificate");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?ServerCertificateName=&Tags=&Action=&Version=#Action=TagServerCertificate"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?ServerCertificateName=&Tags=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?ServerCertificateName=&Tags=&Action=&Version=#Action=TagServerCertificate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?ServerCertificateName=&Tags=&Action=&Version=#Action=TagServerCertificate"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?ServerCertificateName=&Tags=&Action=&Version=#Action=TagServerCertificate")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?ServerCertificateName=&Tags=&Action=&Version=#Action=TagServerCertificate")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?ServerCertificateName=&Tags=&Action=&Version=#Action=TagServerCertificate');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=TagServerCertificate',
  params: {ServerCertificateName: '', Tags: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?ServerCertificateName=&Tags=&Action=&Version=#Action=TagServerCertificate';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?ServerCertificateName=&Tags=&Action=&Version=#Action=TagServerCertificate',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?ServerCertificateName=&Tags=&Action=&Version=#Action=TagServerCertificate")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?ServerCertificateName=&Tags=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=TagServerCertificate',
  qs: {ServerCertificateName: '', Tags: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=TagServerCertificate');

req.query({
  ServerCertificateName: '',
  Tags: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=TagServerCertificate',
  params: {ServerCertificateName: '', Tags: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?ServerCertificateName=&Tags=&Action=&Version=#Action=TagServerCertificate';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?ServerCertificateName=&Tags=&Action=&Version=#Action=TagServerCertificate"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?ServerCertificateName=&Tags=&Action=&Version=#Action=TagServerCertificate" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?ServerCertificateName=&Tags=&Action=&Version=#Action=TagServerCertificate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?ServerCertificateName=&Tags=&Action=&Version=#Action=TagServerCertificate');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=TagServerCertificate');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'ServerCertificateName' => '',
  'Tags' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=TagServerCertificate');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'ServerCertificateName' => '',
  'Tags' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?ServerCertificateName=&Tags=&Action=&Version=#Action=TagServerCertificate' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?ServerCertificateName=&Tags=&Action=&Version=#Action=TagServerCertificate' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?ServerCertificateName=&Tags=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=TagServerCertificate"

querystring = {"ServerCertificateName":"","Tags":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=TagServerCertificate"

queryString <- list(
  ServerCertificateName = "",
  Tags = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?ServerCertificateName=&Tags=&Action=&Version=#Action=TagServerCertificate")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['ServerCertificateName'] = ''
  req.params['Tags'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=TagServerCertificate";

    let querystring = [
        ("ServerCertificateName", ""),
        ("Tags", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?ServerCertificateName=&Tags=&Action=&Version=#Action=TagServerCertificate'
http GET '{{baseUrl}}/?ServerCertificateName=&Tags=&Action=&Version=#Action=TagServerCertificate'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?ServerCertificateName=&Tags=&Action=&Version=#Action=TagServerCertificate'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?ServerCertificateName=&Tags=&Action=&Version=#Action=TagServerCertificate")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_TagUser
{{baseUrl}}/#Action=TagUser
QUERY PARAMS
UserName
Tags
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?UserName=&Tags=&Action=&Version=#Action=TagUser");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=TagUser" {:query-params {:UserName ""
                                                                          :Tags ""
                                                                          :Action ""
                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?UserName=&Tags=&Action=&Version=#Action=TagUser"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?UserName=&Tags=&Action=&Version=#Action=TagUser"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?UserName=&Tags=&Action=&Version=#Action=TagUser");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?UserName=&Tags=&Action=&Version=#Action=TagUser"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?UserName=&Tags=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?UserName=&Tags=&Action=&Version=#Action=TagUser")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?UserName=&Tags=&Action=&Version=#Action=TagUser"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?UserName=&Tags=&Action=&Version=#Action=TagUser")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?UserName=&Tags=&Action=&Version=#Action=TagUser")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?UserName=&Tags=&Action=&Version=#Action=TagUser');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=TagUser',
  params: {UserName: '', Tags: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?UserName=&Tags=&Action=&Version=#Action=TagUser';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?UserName=&Tags=&Action=&Version=#Action=TagUser',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?UserName=&Tags=&Action=&Version=#Action=TagUser")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?UserName=&Tags=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=TagUser',
  qs: {UserName: '', Tags: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=TagUser');

req.query({
  UserName: '',
  Tags: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=TagUser',
  params: {UserName: '', Tags: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?UserName=&Tags=&Action=&Version=#Action=TagUser';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?UserName=&Tags=&Action=&Version=#Action=TagUser"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?UserName=&Tags=&Action=&Version=#Action=TagUser" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?UserName=&Tags=&Action=&Version=#Action=TagUser",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?UserName=&Tags=&Action=&Version=#Action=TagUser');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=TagUser');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'UserName' => '',
  'Tags' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=TagUser');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'UserName' => '',
  'Tags' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?UserName=&Tags=&Action=&Version=#Action=TagUser' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?UserName=&Tags=&Action=&Version=#Action=TagUser' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?UserName=&Tags=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=TagUser"

querystring = {"UserName":"","Tags":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=TagUser"

queryString <- list(
  UserName = "",
  Tags = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?UserName=&Tags=&Action=&Version=#Action=TagUser")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['UserName'] = ''
  req.params['Tags'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=TagUser";

    let querystring = [
        ("UserName", ""),
        ("Tags", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?UserName=&Tags=&Action=&Version=#Action=TagUser'
http GET '{{baseUrl}}/?UserName=&Tags=&Action=&Version=#Action=TagUser'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?UserName=&Tags=&Action=&Version=#Action=TagUser'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?UserName=&Tags=&Action=&Version=#Action=TagUser")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_UntagInstanceProfile
{{baseUrl}}/#Action=UntagInstanceProfile
QUERY PARAMS
InstanceProfileName
TagKeys
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?InstanceProfileName=&TagKeys=&Action=&Version=#Action=UntagInstanceProfile");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=UntagInstanceProfile" {:query-params {:InstanceProfileName ""
                                                                                       :TagKeys ""
                                                                                       :Action ""
                                                                                       :Version ""}})
require "http/client"

url = "{{baseUrl}}/?InstanceProfileName=&TagKeys=&Action=&Version=#Action=UntagInstanceProfile"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?InstanceProfileName=&TagKeys=&Action=&Version=#Action=UntagInstanceProfile"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?InstanceProfileName=&TagKeys=&Action=&Version=#Action=UntagInstanceProfile");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?InstanceProfileName=&TagKeys=&Action=&Version=#Action=UntagInstanceProfile"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?InstanceProfileName=&TagKeys=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?InstanceProfileName=&TagKeys=&Action=&Version=#Action=UntagInstanceProfile")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?InstanceProfileName=&TagKeys=&Action=&Version=#Action=UntagInstanceProfile"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?InstanceProfileName=&TagKeys=&Action=&Version=#Action=UntagInstanceProfile")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?InstanceProfileName=&TagKeys=&Action=&Version=#Action=UntagInstanceProfile")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?InstanceProfileName=&TagKeys=&Action=&Version=#Action=UntagInstanceProfile');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UntagInstanceProfile',
  params: {InstanceProfileName: '', TagKeys: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?InstanceProfileName=&TagKeys=&Action=&Version=#Action=UntagInstanceProfile';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?InstanceProfileName=&TagKeys=&Action=&Version=#Action=UntagInstanceProfile',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?InstanceProfileName=&TagKeys=&Action=&Version=#Action=UntagInstanceProfile")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?InstanceProfileName=&TagKeys=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UntagInstanceProfile',
  qs: {InstanceProfileName: '', TagKeys: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=UntagInstanceProfile');

req.query({
  InstanceProfileName: '',
  TagKeys: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UntagInstanceProfile',
  params: {InstanceProfileName: '', TagKeys: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?InstanceProfileName=&TagKeys=&Action=&Version=#Action=UntagInstanceProfile';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?InstanceProfileName=&TagKeys=&Action=&Version=#Action=UntagInstanceProfile"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?InstanceProfileName=&TagKeys=&Action=&Version=#Action=UntagInstanceProfile" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?InstanceProfileName=&TagKeys=&Action=&Version=#Action=UntagInstanceProfile",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?InstanceProfileName=&TagKeys=&Action=&Version=#Action=UntagInstanceProfile');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UntagInstanceProfile');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'InstanceProfileName' => '',
  'TagKeys' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UntagInstanceProfile');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'InstanceProfileName' => '',
  'TagKeys' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?InstanceProfileName=&TagKeys=&Action=&Version=#Action=UntagInstanceProfile' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?InstanceProfileName=&TagKeys=&Action=&Version=#Action=UntagInstanceProfile' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?InstanceProfileName=&TagKeys=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UntagInstanceProfile"

querystring = {"InstanceProfileName":"","TagKeys":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UntagInstanceProfile"

queryString <- list(
  InstanceProfileName = "",
  TagKeys = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?InstanceProfileName=&TagKeys=&Action=&Version=#Action=UntagInstanceProfile")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['InstanceProfileName'] = ''
  req.params['TagKeys'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UntagInstanceProfile";

    let querystring = [
        ("InstanceProfileName", ""),
        ("TagKeys", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?InstanceProfileName=&TagKeys=&Action=&Version=#Action=UntagInstanceProfile'
http GET '{{baseUrl}}/?InstanceProfileName=&TagKeys=&Action=&Version=#Action=UntagInstanceProfile'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?InstanceProfileName=&TagKeys=&Action=&Version=#Action=UntagInstanceProfile'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?InstanceProfileName=&TagKeys=&Action=&Version=#Action=UntagInstanceProfile")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_UntagMFADevice
{{baseUrl}}/#Action=UntagMFADevice
QUERY PARAMS
SerialNumber
TagKeys
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?SerialNumber=&TagKeys=&Action=&Version=#Action=UntagMFADevice");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=UntagMFADevice" {:query-params {:SerialNumber ""
                                                                                 :TagKeys ""
                                                                                 :Action ""
                                                                                 :Version ""}})
require "http/client"

url = "{{baseUrl}}/?SerialNumber=&TagKeys=&Action=&Version=#Action=UntagMFADevice"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?SerialNumber=&TagKeys=&Action=&Version=#Action=UntagMFADevice"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?SerialNumber=&TagKeys=&Action=&Version=#Action=UntagMFADevice");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?SerialNumber=&TagKeys=&Action=&Version=#Action=UntagMFADevice"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?SerialNumber=&TagKeys=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?SerialNumber=&TagKeys=&Action=&Version=#Action=UntagMFADevice")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?SerialNumber=&TagKeys=&Action=&Version=#Action=UntagMFADevice"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?SerialNumber=&TagKeys=&Action=&Version=#Action=UntagMFADevice")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?SerialNumber=&TagKeys=&Action=&Version=#Action=UntagMFADevice")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?SerialNumber=&TagKeys=&Action=&Version=#Action=UntagMFADevice');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UntagMFADevice',
  params: {SerialNumber: '', TagKeys: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?SerialNumber=&TagKeys=&Action=&Version=#Action=UntagMFADevice';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?SerialNumber=&TagKeys=&Action=&Version=#Action=UntagMFADevice',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?SerialNumber=&TagKeys=&Action=&Version=#Action=UntagMFADevice")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?SerialNumber=&TagKeys=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UntagMFADevice',
  qs: {SerialNumber: '', TagKeys: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=UntagMFADevice');

req.query({
  SerialNumber: '',
  TagKeys: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UntagMFADevice',
  params: {SerialNumber: '', TagKeys: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?SerialNumber=&TagKeys=&Action=&Version=#Action=UntagMFADevice';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?SerialNumber=&TagKeys=&Action=&Version=#Action=UntagMFADevice"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?SerialNumber=&TagKeys=&Action=&Version=#Action=UntagMFADevice" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?SerialNumber=&TagKeys=&Action=&Version=#Action=UntagMFADevice",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?SerialNumber=&TagKeys=&Action=&Version=#Action=UntagMFADevice');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UntagMFADevice');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'SerialNumber' => '',
  'TagKeys' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UntagMFADevice');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'SerialNumber' => '',
  'TagKeys' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?SerialNumber=&TagKeys=&Action=&Version=#Action=UntagMFADevice' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?SerialNumber=&TagKeys=&Action=&Version=#Action=UntagMFADevice' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?SerialNumber=&TagKeys=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UntagMFADevice"

querystring = {"SerialNumber":"","TagKeys":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UntagMFADevice"

queryString <- list(
  SerialNumber = "",
  TagKeys = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?SerialNumber=&TagKeys=&Action=&Version=#Action=UntagMFADevice")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['SerialNumber'] = ''
  req.params['TagKeys'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UntagMFADevice";

    let querystring = [
        ("SerialNumber", ""),
        ("TagKeys", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?SerialNumber=&TagKeys=&Action=&Version=#Action=UntagMFADevice'
http GET '{{baseUrl}}/?SerialNumber=&TagKeys=&Action=&Version=#Action=UntagMFADevice'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?SerialNumber=&TagKeys=&Action=&Version=#Action=UntagMFADevice'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?SerialNumber=&TagKeys=&Action=&Version=#Action=UntagMFADevice")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_UntagOpenIDConnectProvider
{{baseUrl}}/#Action=UntagOpenIDConnectProvider
QUERY PARAMS
OpenIDConnectProviderArn
TagKeys
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?OpenIDConnectProviderArn=&TagKeys=&Action=&Version=#Action=UntagOpenIDConnectProvider");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=UntagOpenIDConnectProvider" {:query-params {:OpenIDConnectProviderArn ""
                                                                                             :TagKeys ""
                                                                                             :Action ""
                                                                                             :Version ""}})
require "http/client"

url = "{{baseUrl}}/?OpenIDConnectProviderArn=&TagKeys=&Action=&Version=#Action=UntagOpenIDConnectProvider"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?OpenIDConnectProviderArn=&TagKeys=&Action=&Version=#Action=UntagOpenIDConnectProvider"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?OpenIDConnectProviderArn=&TagKeys=&Action=&Version=#Action=UntagOpenIDConnectProvider");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?OpenIDConnectProviderArn=&TagKeys=&Action=&Version=#Action=UntagOpenIDConnectProvider"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?OpenIDConnectProviderArn=&TagKeys=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?OpenIDConnectProviderArn=&TagKeys=&Action=&Version=#Action=UntagOpenIDConnectProvider")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?OpenIDConnectProviderArn=&TagKeys=&Action=&Version=#Action=UntagOpenIDConnectProvider"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?OpenIDConnectProviderArn=&TagKeys=&Action=&Version=#Action=UntagOpenIDConnectProvider")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?OpenIDConnectProviderArn=&TagKeys=&Action=&Version=#Action=UntagOpenIDConnectProvider")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?OpenIDConnectProviderArn=&TagKeys=&Action=&Version=#Action=UntagOpenIDConnectProvider');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UntagOpenIDConnectProvider',
  params: {OpenIDConnectProviderArn: '', TagKeys: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?OpenIDConnectProviderArn=&TagKeys=&Action=&Version=#Action=UntagOpenIDConnectProvider';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?OpenIDConnectProviderArn=&TagKeys=&Action=&Version=#Action=UntagOpenIDConnectProvider',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?OpenIDConnectProviderArn=&TagKeys=&Action=&Version=#Action=UntagOpenIDConnectProvider")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?OpenIDConnectProviderArn=&TagKeys=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UntagOpenIDConnectProvider',
  qs: {OpenIDConnectProviderArn: '', TagKeys: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=UntagOpenIDConnectProvider');

req.query({
  OpenIDConnectProviderArn: '',
  TagKeys: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UntagOpenIDConnectProvider',
  params: {OpenIDConnectProviderArn: '', TagKeys: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?OpenIDConnectProviderArn=&TagKeys=&Action=&Version=#Action=UntagOpenIDConnectProvider';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?OpenIDConnectProviderArn=&TagKeys=&Action=&Version=#Action=UntagOpenIDConnectProvider"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?OpenIDConnectProviderArn=&TagKeys=&Action=&Version=#Action=UntagOpenIDConnectProvider" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?OpenIDConnectProviderArn=&TagKeys=&Action=&Version=#Action=UntagOpenIDConnectProvider",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?OpenIDConnectProviderArn=&TagKeys=&Action=&Version=#Action=UntagOpenIDConnectProvider');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UntagOpenIDConnectProvider');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'OpenIDConnectProviderArn' => '',
  'TagKeys' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UntagOpenIDConnectProvider');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'OpenIDConnectProviderArn' => '',
  'TagKeys' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?OpenIDConnectProviderArn=&TagKeys=&Action=&Version=#Action=UntagOpenIDConnectProvider' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?OpenIDConnectProviderArn=&TagKeys=&Action=&Version=#Action=UntagOpenIDConnectProvider' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?OpenIDConnectProviderArn=&TagKeys=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UntagOpenIDConnectProvider"

querystring = {"OpenIDConnectProviderArn":"","TagKeys":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UntagOpenIDConnectProvider"

queryString <- list(
  OpenIDConnectProviderArn = "",
  TagKeys = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?OpenIDConnectProviderArn=&TagKeys=&Action=&Version=#Action=UntagOpenIDConnectProvider")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['OpenIDConnectProviderArn'] = ''
  req.params['TagKeys'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UntagOpenIDConnectProvider";

    let querystring = [
        ("OpenIDConnectProviderArn", ""),
        ("TagKeys", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?OpenIDConnectProviderArn=&TagKeys=&Action=&Version=#Action=UntagOpenIDConnectProvider'
http GET '{{baseUrl}}/?OpenIDConnectProviderArn=&TagKeys=&Action=&Version=#Action=UntagOpenIDConnectProvider'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?OpenIDConnectProviderArn=&TagKeys=&Action=&Version=#Action=UntagOpenIDConnectProvider'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?OpenIDConnectProviderArn=&TagKeys=&Action=&Version=#Action=UntagOpenIDConnectProvider")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_UntagPolicy
{{baseUrl}}/#Action=UntagPolicy
QUERY PARAMS
PolicyArn
TagKeys
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?PolicyArn=&TagKeys=&Action=&Version=#Action=UntagPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=UntagPolicy" {:query-params {:PolicyArn ""
                                                                              :TagKeys ""
                                                                              :Action ""
                                                                              :Version ""}})
require "http/client"

url = "{{baseUrl}}/?PolicyArn=&TagKeys=&Action=&Version=#Action=UntagPolicy"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?PolicyArn=&TagKeys=&Action=&Version=#Action=UntagPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?PolicyArn=&TagKeys=&Action=&Version=#Action=UntagPolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?PolicyArn=&TagKeys=&Action=&Version=#Action=UntagPolicy"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?PolicyArn=&TagKeys=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?PolicyArn=&TagKeys=&Action=&Version=#Action=UntagPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?PolicyArn=&TagKeys=&Action=&Version=#Action=UntagPolicy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?PolicyArn=&TagKeys=&Action=&Version=#Action=UntagPolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?PolicyArn=&TagKeys=&Action=&Version=#Action=UntagPolicy")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?PolicyArn=&TagKeys=&Action=&Version=#Action=UntagPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UntagPolicy',
  params: {PolicyArn: '', TagKeys: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?PolicyArn=&TagKeys=&Action=&Version=#Action=UntagPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?PolicyArn=&TagKeys=&Action=&Version=#Action=UntagPolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?PolicyArn=&TagKeys=&Action=&Version=#Action=UntagPolicy")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?PolicyArn=&TagKeys=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UntagPolicy',
  qs: {PolicyArn: '', TagKeys: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=UntagPolicy');

req.query({
  PolicyArn: '',
  TagKeys: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UntagPolicy',
  params: {PolicyArn: '', TagKeys: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?PolicyArn=&TagKeys=&Action=&Version=#Action=UntagPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?PolicyArn=&TagKeys=&Action=&Version=#Action=UntagPolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?PolicyArn=&TagKeys=&Action=&Version=#Action=UntagPolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?PolicyArn=&TagKeys=&Action=&Version=#Action=UntagPolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?PolicyArn=&TagKeys=&Action=&Version=#Action=UntagPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UntagPolicy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'PolicyArn' => '',
  'TagKeys' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UntagPolicy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'PolicyArn' => '',
  'TagKeys' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?PolicyArn=&TagKeys=&Action=&Version=#Action=UntagPolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?PolicyArn=&TagKeys=&Action=&Version=#Action=UntagPolicy' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?PolicyArn=&TagKeys=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UntagPolicy"

querystring = {"PolicyArn":"","TagKeys":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UntagPolicy"

queryString <- list(
  PolicyArn = "",
  TagKeys = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?PolicyArn=&TagKeys=&Action=&Version=#Action=UntagPolicy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['PolicyArn'] = ''
  req.params['TagKeys'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UntagPolicy";

    let querystring = [
        ("PolicyArn", ""),
        ("TagKeys", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?PolicyArn=&TagKeys=&Action=&Version=#Action=UntagPolicy'
http GET '{{baseUrl}}/?PolicyArn=&TagKeys=&Action=&Version=#Action=UntagPolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?PolicyArn=&TagKeys=&Action=&Version=#Action=UntagPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?PolicyArn=&TagKeys=&Action=&Version=#Action=UntagPolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_UntagRole
{{baseUrl}}/#Action=UntagRole
QUERY PARAMS
RoleName
TagKeys
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?RoleName=&TagKeys=&Action=&Version=#Action=UntagRole");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=UntagRole" {:query-params {:RoleName ""
                                                                            :TagKeys ""
                                                                            :Action ""
                                                                            :Version ""}})
require "http/client"

url = "{{baseUrl}}/?RoleName=&TagKeys=&Action=&Version=#Action=UntagRole"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?RoleName=&TagKeys=&Action=&Version=#Action=UntagRole"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?RoleName=&TagKeys=&Action=&Version=#Action=UntagRole");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?RoleName=&TagKeys=&Action=&Version=#Action=UntagRole"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?RoleName=&TagKeys=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?RoleName=&TagKeys=&Action=&Version=#Action=UntagRole")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?RoleName=&TagKeys=&Action=&Version=#Action=UntagRole"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?RoleName=&TagKeys=&Action=&Version=#Action=UntagRole")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?RoleName=&TagKeys=&Action=&Version=#Action=UntagRole")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?RoleName=&TagKeys=&Action=&Version=#Action=UntagRole');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UntagRole',
  params: {RoleName: '', TagKeys: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?RoleName=&TagKeys=&Action=&Version=#Action=UntagRole';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?RoleName=&TagKeys=&Action=&Version=#Action=UntagRole',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?RoleName=&TagKeys=&Action=&Version=#Action=UntagRole")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?RoleName=&TagKeys=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UntagRole',
  qs: {RoleName: '', TagKeys: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=UntagRole');

req.query({
  RoleName: '',
  TagKeys: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UntagRole',
  params: {RoleName: '', TagKeys: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?RoleName=&TagKeys=&Action=&Version=#Action=UntagRole';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?RoleName=&TagKeys=&Action=&Version=#Action=UntagRole"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?RoleName=&TagKeys=&Action=&Version=#Action=UntagRole" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?RoleName=&TagKeys=&Action=&Version=#Action=UntagRole",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?RoleName=&TagKeys=&Action=&Version=#Action=UntagRole');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UntagRole');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'RoleName' => '',
  'TagKeys' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UntagRole');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'RoleName' => '',
  'TagKeys' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?RoleName=&TagKeys=&Action=&Version=#Action=UntagRole' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?RoleName=&TagKeys=&Action=&Version=#Action=UntagRole' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?RoleName=&TagKeys=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UntagRole"

querystring = {"RoleName":"","TagKeys":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UntagRole"

queryString <- list(
  RoleName = "",
  TagKeys = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?RoleName=&TagKeys=&Action=&Version=#Action=UntagRole")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['RoleName'] = ''
  req.params['TagKeys'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UntagRole";

    let querystring = [
        ("RoleName", ""),
        ("TagKeys", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?RoleName=&TagKeys=&Action=&Version=#Action=UntagRole'
http GET '{{baseUrl}}/?RoleName=&TagKeys=&Action=&Version=#Action=UntagRole'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?RoleName=&TagKeys=&Action=&Version=#Action=UntagRole'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?RoleName=&TagKeys=&Action=&Version=#Action=UntagRole")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_UntagSAMLProvider
{{baseUrl}}/#Action=UntagSAMLProvider
QUERY PARAMS
SAMLProviderArn
TagKeys
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?SAMLProviderArn=&TagKeys=&Action=&Version=#Action=UntagSAMLProvider");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=UntagSAMLProvider" {:query-params {:SAMLProviderArn ""
                                                                                    :TagKeys ""
                                                                                    :Action ""
                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?SAMLProviderArn=&TagKeys=&Action=&Version=#Action=UntagSAMLProvider"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?SAMLProviderArn=&TagKeys=&Action=&Version=#Action=UntagSAMLProvider"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?SAMLProviderArn=&TagKeys=&Action=&Version=#Action=UntagSAMLProvider");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?SAMLProviderArn=&TagKeys=&Action=&Version=#Action=UntagSAMLProvider"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?SAMLProviderArn=&TagKeys=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?SAMLProviderArn=&TagKeys=&Action=&Version=#Action=UntagSAMLProvider")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?SAMLProviderArn=&TagKeys=&Action=&Version=#Action=UntagSAMLProvider"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?SAMLProviderArn=&TagKeys=&Action=&Version=#Action=UntagSAMLProvider")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?SAMLProviderArn=&TagKeys=&Action=&Version=#Action=UntagSAMLProvider")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?SAMLProviderArn=&TagKeys=&Action=&Version=#Action=UntagSAMLProvider');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UntagSAMLProvider',
  params: {SAMLProviderArn: '', TagKeys: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?SAMLProviderArn=&TagKeys=&Action=&Version=#Action=UntagSAMLProvider';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?SAMLProviderArn=&TagKeys=&Action=&Version=#Action=UntagSAMLProvider',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?SAMLProviderArn=&TagKeys=&Action=&Version=#Action=UntagSAMLProvider")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?SAMLProviderArn=&TagKeys=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UntagSAMLProvider',
  qs: {SAMLProviderArn: '', TagKeys: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=UntagSAMLProvider');

req.query({
  SAMLProviderArn: '',
  TagKeys: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UntagSAMLProvider',
  params: {SAMLProviderArn: '', TagKeys: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?SAMLProviderArn=&TagKeys=&Action=&Version=#Action=UntagSAMLProvider';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?SAMLProviderArn=&TagKeys=&Action=&Version=#Action=UntagSAMLProvider"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?SAMLProviderArn=&TagKeys=&Action=&Version=#Action=UntagSAMLProvider" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?SAMLProviderArn=&TagKeys=&Action=&Version=#Action=UntagSAMLProvider",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?SAMLProviderArn=&TagKeys=&Action=&Version=#Action=UntagSAMLProvider');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UntagSAMLProvider');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'SAMLProviderArn' => '',
  'TagKeys' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UntagSAMLProvider');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'SAMLProviderArn' => '',
  'TagKeys' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?SAMLProviderArn=&TagKeys=&Action=&Version=#Action=UntagSAMLProvider' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?SAMLProviderArn=&TagKeys=&Action=&Version=#Action=UntagSAMLProvider' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?SAMLProviderArn=&TagKeys=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UntagSAMLProvider"

querystring = {"SAMLProviderArn":"","TagKeys":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UntagSAMLProvider"

queryString <- list(
  SAMLProviderArn = "",
  TagKeys = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?SAMLProviderArn=&TagKeys=&Action=&Version=#Action=UntagSAMLProvider")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['SAMLProviderArn'] = ''
  req.params['TagKeys'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UntagSAMLProvider";

    let querystring = [
        ("SAMLProviderArn", ""),
        ("TagKeys", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?SAMLProviderArn=&TagKeys=&Action=&Version=#Action=UntagSAMLProvider'
http GET '{{baseUrl}}/?SAMLProviderArn=&TagKeys=&Action=&Version=#Action=UntagSAMLProvider'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?SAMLProviderArn=&TagKeys=&Action=&Version=#Action=UntagSAMLProvider'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?SAMLProviderArn=&TagKeys=&Action=&Version=#Action=UntagSAMLProvider")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_UntagServerCertificate
{{baseUrl}}/#Action=UntagServerCertificate
QUERY PARAMS
ServerCertificateName
TagKeys
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?ServerCertificateName=&TagKeys=&Action=&Version=#Action=UntagServerCertificate");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=UntagServerCertificate" {:query-params {:ServerCertificateName ""
                                                                                         :TagKeys ""
                                                                                         :Action ""
                                                                                         :Version ""}})
require "http/client"

url = "{{baseUrl}}/?ServerCertificateName=&TagKeys=&Action=&Version=#Action=UntagServerCertificate"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?ServerCertificateName=&TagKeys=&Action=&Version=#Action=UntagServerCertificate"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?ServerCertificateName=&TagKeys=&Action=&Version=#Action=UntagServerCertificate");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?ServerCertificateName=&TagKeys=&Action=&Version=#Action=UntagServerCertificate"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?ServerCertificateName=&TagKeys=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?ServerCertificateName=&TagKeys=&Action=&Version=#Action=UntagServerCertificate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?ServerCertificateName=&TagKeys=&Action=&Version=#Action=UntagServerCertificate"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?ServerCertificateName=&TagKeys=&Action=&Version=#Action=UntagServerCertificate")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?ServerCertificateName=&TagKeys=&Action=&Version=#Action=UntagServerCertificate")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?ServerCertificateName=&TagKeys=&Action=&Version=#Action=UntagServerCertificate');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UntagServerCertificate',
  params: {ServerCertificateName: '', TagKeys: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?ServerCertificateName=&TagKeys=&Action=&Version=#Action=UntagServerCertificate';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?ServerCertificateName=&TagKeys=&Action=&Version=#Action=UntagServerCertificate',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?ServerCertificateName=&TagKeys=&Action=&Version=#Action=UntagServerCertificate")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?ServerCertificateName=&TagKeys=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UntagServerCertificate',
  qs: {ServerCertificateName: '', TagKeys: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=UntagServerCertificate');

req.query({
  ServerCertificateName: '',
  TagKeys: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UntagServerCertificate',
  params: {ServerCertificateName: '', TagKeys: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?ServerCertificateName=&TagKeys=&Action=&Version=#Action=UntagServerCertificate';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?ServerCertificateName=&TagKeys=&Action=&Version=#Action=UntagServerCertificate"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?ServerCertificateName=&TagKeys=&Action=&Version=#Action=UntagServerCertificate" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?ServerCertificateName=&TagKeys=&Action=&Version=#Action=UntagServerCertificate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?ServerCertificateName=&TagKeys=&Action=&Version=#Action=UntagServerCertificate');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UntagServerCertificate');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'ServerCertificateName' => '',
  'TagKeys' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UntagServerCertificate');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'ServerCertificateName' => '',
  'TagKeys' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?ServerCertificateName=&TagKeys=&Action=&Version=#Action=UntagServerCertificate' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?ServerCertificateName=&TagKeys=&Action=&Version=#Action=UntagServerCertificate' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?ServerCertificateName=&TagKeys=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UntagServerCertificate"

querystring = {"ServerCertificateName":"","TagKeys":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UntagServerCertificate"

queryString <- list(
  ServerCertificateName = "",
  TagKeys = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?ServerCertificateName=&TagKeys=&Action=&Version=#Action=UntagServerCertificate")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['ServerCertificateName'] = ''
  req.params['TagKeys'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UntagServerCertificate";

    let querystring = [
        ("ServerCertificateName", ""),
        ("TagKeys", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?ServerCertificateName=&TagKeys=&Action=&Version=#Action=UntagServerCertificate'
http GET '{{baseUrl}}/?ServerCertificateName=&TagKeys=&Action=&Version=#Action=UntagServerCertificate'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?ServerCertificateName=&TagKeys=&Action=&Version=#Action=UntagServerCertificate'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?ServerCertificateName=&TagKeys=&Action=&Version=#Action=UntagServerCertificate")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_UntagUser
{{baseUrl}}/#Action=UntagUser
QUERY PARAMS
UserName
TagKeys
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?UserName=&TagKeys=&Action=&Version=#Action=UntagUser");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=UntagUser" {:query-params {:UserName ""
                                                                            :TagKeys ""
                                                                            :Action ""
                                                                            :Version ""}})
require "http/client"

url = "{{baseUrl}}/?UserName=&TagKeys=&Action=&Version=#Action=UntagUser"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?UserName=&TagKeys=&Action=&Version=#Action=UntagUser"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?UserName=&TagKeys=&Action=&Version=#Action=UntagUser");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?UserName=&TagKeys=&Action=&Version=#Action=UntagUser"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?UserName=&TagKeys=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?UserName=&TagKeys=&Action=&Version=#Action=UntagUser")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?UserName=&TagKeys=&Action=&Version=#Action=UntagUser"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?UserName=&TagKeys=&Action=&Version=#Action=UntagUser")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?UserName=&TagKeys=&Action=&Version=#Action=UntagUser")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?UserName=&TagKeys=&Action=&Version=#Action=UntagUser');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UntagUser',
  params: {UserName: '', TagKeys: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?UserName=&TagKeys=&Action=&Version=#Action=UntagUser';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?UserName=&TagKeys=&Action=&Version=#Action=UntagUser',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?UserName=&TagKeys=&Action=&Version=#Action=UntagUser")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?UserName=&TagKeys=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UntagUser',
  qs: {UserName: '', TagKeys: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=UntagUser');

req.query({
  UserName: '',
  TagKeys: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UntagUser',
  params: {UserName: '', TagKeys: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?UserName=&TagKeys=&Action=&Version=#Action=UntagUser';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?UserName=&TagKeys=&Action=&Version=#Action=UntagUser"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?UserName=&TagKeys=&Action=&Version=#Action=UntagUser" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?UserName=&TagKeys=&Action=&Version=#Action=UntagUser",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?UserName=&TagKeys=&Action=&Version=#Action=UntagUser');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UntagUser');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'UserName' => '',
  'TagKeys' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UntagUser');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'UserName' => '',
  'TagKeys' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?UserName=&TagKeys=&Action=&Version=#Action=UntagUser' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?UserName=&TagKeys=&Action=&Version=#Action=UntagUser' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?UserName=&TagKeys=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UntagUser"

querystring = {"UserName":"","TagKeys":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UntagUser"

queryString <- list(
  UserName = "",
  TagKeys = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?UserName=&TagKeys=&Action=&Version=#Action=UntagUser")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['UserName'] = ''
  req.params['TagKeys'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UntagUser";

    let querystring = [
        ("UserName", ""),
        ("TagKeys", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?UserName=&TagKeys=&Action=&Version=#Action=UntagUser'
http GET '{{baseUrl}}/?UserName=&TagKeys=&Action=&Version=#Action=UntagUser'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?UserName=&TagKeys=&Action=&Version=#Action=UntagUser'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?UserName=&TagKeys=&Action=&Version=#Action=UntagUser")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_UpdateAccessKey
{{baseUrl}}/#Action=UpdateAccessKey
QUERY PARAMS
AccessKeyId
Status
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?AccessKeyId=&Status=&Action=&Version=#Action=UpdateAccessKey");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=UpdateAccessKey" {:query-params {:AccessKeyId ""
                                                                                  :Status ""
                                                                                  :Action ""
                                                                                  :Version ""}})
require "http/client"

url = "{{baseUrl}}/?AccessKeyId=&Status=&Action=&Version=#Action=UpdateAccessKey"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?AccessKeyId=&Status=&Action=&Version=#Action=UpdateAccessKey"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?AccessKeyId=&Status=&Action=&Version=#Action=UpdateAccessKey");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?AccessKeyId=&Status=&Action=&Version=#Action=UpdateAccessKey"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?AccessKeyId=&Status=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?AccessKeyId=&Status=&Action=&Version=#Action=UpdateAccessKey")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?AccessKeyId=&Status=&Action=&Version=#Action=UpdateAccessKey"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?AccessKeyId=&Status=&Action=&Version=#Action=UpdateAccessKey")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?AccessKeyId=&Status=&Action=&Version=#Action=UpdateAccessKey")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?AccessKeyId=&Status=&Action=&Version=#Action=UpdateAccessKey');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateAccessKey',
  params: {AccessKeyId: '', Status: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?AccessKeyId=&Status=&Action=&Version=#Action=UpdateAccessKey';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?AccessKeyId=&Status=&Action=&Version=#Action=UpdateAccessKey',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?AccessKeyId=&Status=&Action=&Version=#Action=UpdateAccessKey")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?AccessKeyId=&Status=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateAccessKey',
  qs: {AccessKeyId: '', Status: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=UpdateAccessKey');

req.query({
  AccessKeyId: '',
  Status: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateAccessKey',
  params: {AccessKeyId: '', Status: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?AccessKeyId=&Status=&Action=&Version=#Action=UpdateAccessKey';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?AccessKeyId=&Status=&Action=&Version=#Action=UpdateAccessKey"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?AccessKeyId=&Status=&Action=&Version=#Action=UpdateAccessKey" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?AccessKeyId=&Status=&Action=&Version=#Action=UpdateAccessKey",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?AccessKeyId=&Status=&Action=&Version=#Action=UpdateAccessKey');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UpdateAccessKey');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'AccessKeyId' => '',
  'Status' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UpdateAccessKey');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'AccessKeyId' => '',
  'Status' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?AccessKeyId=&Status=&Action=&Version=#Action=UpdateAccessKey' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?AccessKeyId=&Status=&Action=&Version=#Action=UpdateAccessKey' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?AccessKeyId=&Status=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UpdateAccessKey"

querystring = {"AccessKeyId":"","Status":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UpdateAccessKey"

queryString <- list(
  AccessKeyId = "",
  Status = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?AccessKeyId=&Status=&Action=&Version=#Action=UpdateAccessKey")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['AccessKeyId'] = ''
  req.params['Status'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UpdateAccessKey";

    let querystring = [
        ("AccessKeyId", ""),
        ("Status", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?AccessKeyId=&Status=&Action=&Version=#Action=UpdateAccessKey'
http GET '{{baseUrl}}/?AccessKeyId=&Status=&Action=&Version=#Action=UpdateAccessKey'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?AccessKeyId=&Status=&Action=&Version=#Action=UpdateAccessKey'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?AccessKeyId=&Status=&Action=&Version=#Action=UpdateAccessKey")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_UpdateAccountPasswordPolicy
{{baseUrl}}/#Action=UpdateAccountPasswordPolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=UpdateAccountPasswordPolicy" {:query-params {:Action ""
                                                                                              :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateAccountPasswordPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateAccountPasswordPolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=UpdateAccountPasswordPolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateAccountPasswordPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UpdateAccountPasswordPolicy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UpdateAccountPasswordPolicy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UpdateAccountPasswordPolicy"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UpdateAccountPasswordPolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UpdateAccountPasswordPolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy'
http GET '{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_UpdateAssumeRolePolicy
{{baseUrl}}/#Action=UpdateAssumeRolePolicy
QUERY PARAMS
RoleName
PolicyDocument
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?RoleName=&PolicyDocument=&Action=&Version=#Action=UpdateAssumeRolePolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=UpdateAssumeRolePolicy" {:query-params {:RoleName ""
                                                                                         :PolicyDocument ""
                                                                                         :Action ""
                                                                                         :Version ""}})
require "http/client"

url = "{{baseUrl}}/?RoleName=&PolicyDocument=&Action=&Version=#Action=UpdateAssumeRolePolicy"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?RoleName=&PolicyDocument=&Action=&Version=#Action=UpdateAssumeRolePolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?RoleName=&PolicyDocument=&Action=&Version=#Action=UpdateAssumeRolePolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?RoleName=&PolicyDocument=&Action=&Version=#Action=UpdateAssumeRolePolicy"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?RoleName=&PolicyDocument=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?RoleName=&PolicyDocument=&Action=&Version=#Action=UpdateAssumeRolePolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?RoleName=&PolicyDocument=&Action=&Version=#Action=UpdateAssumeRolePolicy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?RoleName=&PolicyDocument=&Action=&Version=#Action=UpdateAssumeRolePolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?RoleName=&PolicyDocument=&Action=&Version=#Action=UpdateAssumeRolePolicy")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?RoleName=&PolicyDocument=&Action=&Version=#Action=UpdateAssumeRolePolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateAssumeRolePolicy',
  params: {RoleName: '', PolicyDocument: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?RoleName=&PolicyDocument=&Action=&Version=#Action=UpdateAssumeRolePolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?RoleName=&PolicyDocument=&Action=&Version=#Action=UpdateAssumeRolePolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?RoleName=&PolicyDocument=&Action=&Version=#Action=UpdateAssumeRolePolicy")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?RoleName=&PolicyDocument=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateAssumeRolePolicy',
  qs: {RoleName: '', PolicyDocument: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=UpdateAssumeRolePolicy');

req.query({
  RoleName: '',
  PolicyDocument: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateAssumeRolePolicy',
  params: {RoleName: '', PolicyDocument: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?RoleName=&PolicyDocument=&Action=&Version=#Action=UpdateAssumeRolePolicy';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?RoleName=&PolicyDocument=&Action=&Version=#Action=UpdateAssumeRolePolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?RoleName=&PolicyDocument=&Action=&Version=#Action=UpdateAssumeRolePolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?RoleName=&PolicyDocument=&Action=&Version=#Action=UpdateAssumeRolePolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?RoleName=&PolicyDocument=&Action=&Version=#Action=UpdateAssumeRolePolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UpdateAssumeRolePolicy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'RoleName' => '',
  'PolicyDocument' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UpdateAssumeRolePolicy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'RoleName' => '',
  'PolicyDocument' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?RoleName=&PolicyDocument=&Action=&Version=#Action=UpdateAssumeRolePolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?RoleName=&PolicyDocument=&Action=&Version=#Action=UpdateAssumeRolePolicy' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?RoleName=&PolicyDocument=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UpdateAssumeRolePolicy"

querystring = {"RoleName":"","PolicyDocument":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UpdateAssumeRolePolicy"

queryString <- list(
  RoleName = "",
  PolicyDocument = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?RoleName=&PolicyDocument=&Action=&Version=#Action=UpdateAssumeRolePolicy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['RoleName'] = ''
  req.params['PolicyDocument'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UpdateAssumeRolePolicy";

    let querystring = [
        ("RoleName", ""),
        ("PolicyDocument", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?RoleName=&PolicyDocument=&Action=&Version=#Action=UpdateAssumeRolePolicy'
http GET '{{baseUrl}}/?RoleName=&PolicyDocument=&Action=&Version=#Action=UpdateAssumeRolePolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?RoleName=&PolicyDocument=&Action=&Version=#Action=UpdateAssumeRolePolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?RoleName=&PolicyDocument=&Action=&Version=#Action=UpdateAssumeRolePolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_UpdateGroup
{{baseUrl}}/#Action=UpdateGroup
QUERY PARAMS
GroupName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?GroupName=&Action=&Version=#Action=UpdateGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=UpdateGroup" {:query-params {:GroupName ""
                                                                              :Action ""
                                                                              :Version ""}})
require "http/client"

url = "{{baseUrl}}/?GroupName=&Action=&Version=#Action=UpdateGroup"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?GroupName=&Action=&Version=#Action=UpdateGroup"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?GroupName=&Action=&Version=#Action=UpdateGroup");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?GroupName=&Action=&Version=#Action=UpdateGroup"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?GroupName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?GroupName=&Action=&Version=#Action=UpdateGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?GroupName=&Action=&Version=#Action=UpdateGroup"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?GroupName=&Action=&Version=#Action=UpdateGroup")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?GroupName=&Action=&Version=#Action=UpdateGroup")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?GroupName=&Action=&Version=#Action=UpdateGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateGroup',
  params: {GroupName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?GroupName=&Action=&Version=#Action=UpdateGroup';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?GroupName=&Action=&Version=#Action=UpdateGroup',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?GroupName=&Action=&Version=#Action=UpdateGroup")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?GroupName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateGroup',
  qs: {GroupName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=UpdateGroup');

req.query({
  GroupName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateGroup',
  params: {GroupName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?GroupName=&Action=&Version=#Action=UpdateGroup';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?GroupName=&Action=&Version=#Action=UpdateGroup"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?GroupName=&Action=&Version=#Action=UpdateGroup" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?GroupName=&Action=&Version=#Action=UpdateGroup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?GroupName=&Action=&Version=#Action=UpdateGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UpdateGroup');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'GroupName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UpdateGroup');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'GroupName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?GroupName=&Action=&Version=#Action=UpdateGroup' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?GroupName=&Action=&Version=#Action=UpdateGroup' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?GroupName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UpdateGroup"

querystring = {"GroupName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UpdateGroup"

queryString <- list(
  GroupName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?GroupName=&Action=&Version=#Action=UpdateGroup")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['GroupName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UpdateGroup";

    let querystring = [
        ("GroupName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?GroupName=&Action=&Version=#Action=UpdateGroup'
http GET '{{baseUrl}}/?GroupName=&Action=&Version=#Action=UpdateGroup'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?GroupName=&Action=&Version=#Action=UpdateGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?GroupName=&Action=&Version=#Action=UpdateGroup")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_UpdateLoginProfile
{{baseUrl}}/#Action=UpdateLoginProfile
QUERY PARAMS
UserName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateLoginProfile");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=UpdateLoginProfile" {:query-params {:UserName ""
                                                                                     :Action ""
                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateLoginProfile"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateLoginProfile"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateLoginProfile");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateLoginProfile"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?UserName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateLoginProfile")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateLoginProfile"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateLoginProfile")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateLoginProfile")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateLoginProfile');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateLoginProfile',
  params: {UserName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateLoginProfile';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateLoginProfile',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateLoginProfile")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?UserName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateLoginProfile',
  qs: {UserName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=UpdateLoginProfile');

req.query({
  UserName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateLoginProfile',
  params: {UserName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateLoginProfile';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateLoginProfile"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateLoginProfile" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateLoginProfile",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateLoginProfile');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UpdateLoginProfile');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'UserName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UpdateLoginProfile');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'UserName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateLoginProfile' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateLoginProfile' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?UserName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UpdateLoginProfile"

querystring = {"UserName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UpdateLoginProfile"

queryString <- list(
  UserName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateLoginProfile")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['UserName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UpdateLoginProfile";

    let querystring = [
        ("UserName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateLoginProfile'
http GET '{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateLoginProfile'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateLoginProfile'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateLoginProfile")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_UpdateOpenIDConnectProviderThumbprint
{{baseUrl}}/#Action=UpdateOpenIDConnectProviderThumbprint
QUERY PARAMS
OpenIDConnectProviderArn
ThumbprintList
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?OpenIDConnectProviderArn=&ThumbprintList=&Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=UpdateOpenIDConnectProviderThumbprint" {:query-params {:OpenIDConnectProviderArn ""
                                                                                                        :ThumbprintList ""
                                                                                                        :Action ""
                                                                                                        :Version ""}})
require "http/client"

url = "{{baseUrl}}/?OpenIDConnectProviderArn=&ThumbprintList=&Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?OpenIDConnectProviderArn=&ThumbprintList=&Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?OpenIDConnectProviderArn=&ThumbprintList=&Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?OpenIDConnectProviderArn=&ThumbprintList=&Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?OpenIDConnectProviderArn=&ThumbprintList=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?OpenIDConnectProviderArn=&ThumbprintList=&Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?OpenIDConnectProviderArn=&ThumbprintList=&Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?OpenIDConnectProviderArn=&ThumbprintList=&Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?OpenIDConnectProviderArn=&ThumbprintList=&Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?OpenIDConnectProviderArn=&ThumbprintList=&Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateOpenIDConnectProviderThumbprint',
  params: {OpenIDConnectProviderArn: '', ThumbprintList: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?OpenIDConnectProviderArn=&ThumbprintList=&Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?OpenIDConnectProviderArn=&ThumbprintList=&Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?OpenIDConnectProviderArn=&ThumbprintList=&Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?OpenIDConnectProviderArn=&ThumbprintList=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateOpenIDConnectProviderThumbprint',
  qs: {OpenIDConnectProviderArn: '', ThumbprintList: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=UpdateOpenIDConnectProviderThumbprint');

req.query({
  OpenIDConnectProviderArn: '',
  ThumbprintList: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateOpenIDConnectProviderThumbprint',
  params: {OpenIDConnectProviderArn: '', ThumbprintList: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?OpenIDConnectProviderArn=&ThumbprintList=&Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?OpenIDConnectProviderArn=&ThumbprintList=&Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?OpenIDConnectProviderArn=&ThumbprintList=&Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?OpenIDConnectProviderArn=&ThumbprintList=&Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?OpenIDConnectProviderArn=&ThumbprintList=&Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UpdateOpenIDConnectProviderThumbprint');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'OpenIDConnectProviderArn' => '',
  'ThumbprintList' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UpdateOpenIDConnectProviderThumbprint');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'OpenIDConnectProviderArn' => '',
  'ThumbprintList' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?OpenIDConnectProviderArn=&ThumbprintList=&Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?OpenIDConnectProviderArn=&ThumbprintList=&Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?OpenIDConnectProviderArn=&ThumbprintList=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UpdateOpenIDConnectProviderThumbprint"

querystring = {"OpenIDConnectProviderArn":"","ThumbprintList":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UpdateOpenIDConnectProviderThumbprint"

queryString <- list(
  OpenIDConnectProviderArn = "",
  ThumbprintList = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?OpenIDConnectProviderArn=&ThumbprintList=&Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['OpenIDConnectProviderArn'] = ''
  req.params['ThumbprintList'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UpdateOpenIDConnectProviderThumbprint";

    let querystring = [
        ("OpenIDConnectProviderArn", ""),
        ("ThumbprintList", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?OpenIDConnectProviderArn=&ThumbprintList=&Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint'
http GET '{{baseUrl}}/?OpenIDConnectProviderArn=&ThumbprintList=&Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?OpenIDConnectProviderArn=&ThumbprintList=&Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?OpenIDConnectProviderArn=&ThumbprintList=&Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_UpdateRole
{{baseUrl}}/#Action=UpdateRole
QUERY PARAMS
RoleName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?RoleName=&Action=&Version=#Action=UpdateRole");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=UpdateRole" {:query-params {:RoleName ""
                                                                             :Action ""
                                                                             :Version ""}})
require "http/client"

url = "{{baseUrl}}/?RoleName=&Action=&Version=#Action=UpdateRole"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?RoleName=&Action=&Version=#Action=UpdateRole"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?RoleName=&Action=&Version=#Action=UpdateRole");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?RoleName=&Action=&Version=#Action=UpdateRole"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?RoleName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?RoleName=&Action=&Version=#Action=UpdateRole")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?RoleName=&Action=&Version=#Action=UpdateRole"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?RoleName=&Action=&Version=#Action=UpdateRole")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?RoleName=&Action=&Version=#Action=UpdateRole")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?RoleName=&Action=&Version=#Action=UpdateRole');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateRole',
  params: {RoleName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?RoleName=&Action=&Version=#Action=UpdateRole';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?RoleName=&Action=&Version=#Action=UpdateRole',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?RoleName=&Action=&Version=#Action=UpdateRole")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?RoleName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateRole',
  qs: {RoleName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=UpdateRole');

req.query({
  RoleName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateRole',
  params: {RoleName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?RoleName=&Action=&Version=#Action=UpdateRole';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?RoleName=&Action=&Version=#Action=UpdateRole"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?RoleName=&Action=&Version=#Action=UpdateRole" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?RoleName=&Action=&Version=#Action=UpdateRole",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?RoleName=&Action=&Version=#Action=UpdateRole');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UpdateRole');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'RoleName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UpdateRole');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'RoleName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?RoleName=&Action=&Version=#Action=UpdateRole' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?RoleName=&Action=&Version=#Action=UpdateRole' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?RoleName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UpdateRole"

querystring = {"RoleName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UpdateRole"

queryString <- list(
  RoleName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?RoleName=&Action=&Version=#Action=UpdateRole")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['RoleName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UpdateRole";

    let querystring = [
        ("RoleName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?RoleName=&Action=&Version=#Action=UpdateRole'
http GET '{{baseUrl}}/?RoleName=&Action=&Version=#Action=UpdateRole'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?RoleName=&Action=&Version=#Action=UpdateRole'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?RoleName=&Action=&Version=#Action=UpdateRole")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_UpdateRoleDescription
{{baseUrl}}/#Action=UpdateRoleDescription
QUERY PARAMS
RoleName
Description
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?RoleName=&Description=&Action=&Version=#Action=UpdateRoleDescription");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=UpdateRoleDescription" {:query-params {:RoleName ""
                                                                                        :Description ""
                                                                                        :Action ""
                                                                                        :Version ""}})
require "http/client"

url = "{{baseUrl}}/?RoleName=&Description=&Action=&Version=#Action=UpdateRoleDescription"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?RoleName=&Description=&Action=&Version=#Action=UpdateRoleDescription"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?RoleName=&Description=&Action=&Version=#Action=UpdateRoleDescription");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?RoleName=&Description=&Action=&Version=#Action=UpdateRoleDescription"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?RoleName=&Description=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?RoleName=&Description=&Action=&Version=#Action=UpdateRoleDescription")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?RoleName=&Description=&Action=&Version=#Action=UpdateRoleDescription"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?RoleName=&Description=&Action=&Version=#Action=UpdateRoleDescription")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?RoleName=&Description=&Action=&Version=#Action=UpdateRoleDescription")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?RoleName=&Description=&Action=&Version=#Action=UpdateRoleDescription');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateRoleDescription',
  params: {RoleName: '', Description: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?RoleName=&Description=&Action=&Version=#Action=UpdateRoleDescription';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?RoleName=&Description=&Action=&Version=#Action=UpdateRoleDescription',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?RoleName=&Description=&Action=&Version=#Action=UpdateRoleDescription")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?RoleName=&Description=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateRoleDescription',
  qs: {RoleName: '', Description: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=UpdateRoleDescription');

req.query({
  RoleName: '',
  Description: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateRoleDescription',
  params: {RoleName: '', Description: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?RoleName=&Description=&Action=&Version=#Action=UpdateRoleDescription';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?RoleName=&Description=&Action=&Version=#Action=UpdateRoleDescription"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?RoleName=&Description=&Action=&Version=#Action=UpdateRoleDescription" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?RoleName=&Description=&Action=&Version=#Action=UpdateRoleDescription",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?RoleName=&Description=&Action=&Version=#Action=UpdateRoleDescription');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UpdateRoleDescription');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'RoleName' => '',
  'Description' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UpdateRoleDescription');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'RoleName' => '',
  'Description' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?RoleName=&Description=&Action=&Version=#Action=UpdateRoleDescription' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?RoleName=&Description=&Action=&Version=#Action=UpdateRoleDescription' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?RoleName=&Description=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UpdateRoleDescription"

querystring = {"RoleName":"","Description":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UpdateRoleDescription"

queryString <- list(
  RoleName = "",
  Description = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?RoleName=&Description=&Action=&Version=#Action=UpdateRoleDescription")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['RoleName'] = ''
  req.params['Description'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UpdateRoleDescription";

    let querystring = [
        ("RoleName", ""),
        ("Description", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?RoleName=&Description=&Action=&Version=#Action=UpdateRoleDescription'
http GET '{{baseUrl}}/?RoleName=&Description=&Action=&Version=#Action=UpdateRoleDescription'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?RoleName=&Description=&Action=&Version=#Action=UpdateRoleDescription'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?RoleName=&Description=&Action=&Version=#Action=UpdateRoleDescription")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_UpdateSAMLProvider
{{baseUrl}}/#Action=UpdateSAMLProvider
QUERY PARAMS
SAMLMetadataDocument
SAMLProviderArn
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?SAMLMetadataDocument=&SAMLProviderArn=&Action=&Version=#Action=UpdateSAMLProvider");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=UpdateSAMLProvider" {:query-params {:SAMLMetadataDocument ""
                                                                                     :SAMLProviderArn ""
                                                                                     :Action ""
                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?SAMLMetadataDocument=&SAMLProviderArn=&Action=&Version=#Action=UpdateSAMLProvider"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?SAMLMetadataDocument=&SAMLProviderArn=&Action=&Version=#Action=UpdateSAMLProvider"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?SAMLMetadataDocument=&SAMLProviderArn=&Action=&Version=#Action=UpdateSAMLProvider");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?SAMLMetadataDocument=&SAMLProviderArn=&Action=&Version=#Action=UpdateSAMLProvider"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?SAMLMetadataDocument=&SAMLProviderArn=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?SAMLMetadataDocument=&SAMLProviderArn=&Action=&Version=#Action=UpdateSAMLProvider")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?SAMLMetadataDocument=&SAMLProviderArn=&Action=&Version=#Action=UpdateSAMLProvider"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?SAMLMetadataDocument=&SAMLProviderArn=&Action=&Version=#Action=UpdateSAMLProvider")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?SAMLMetadataDocument=&SAMLProviderArn=&Action=&Version=#Action=UpdateSAMLProvider")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?SAMLMetadataDocument=&SAMLProviderArn=&Action=&Version=#Action=UpdateSAMLProvider');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateSAMLProvider',
  params: {SAMLMetadataDocument: '', SAMLProviderArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?SAMLMetadataDocument=&SAMLProviderArn=&Action=&Version=#Action=UpdateSAMLProvider';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?SAMLMetadataDocument=&SAMLProviderArn=&Action=&Version=#Action=UpdateSAMLProvider',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?SAMLMetadataDocument=&SAMLProviderArn=&Action=&Version=#Action=UpdateSAMLProvider")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?SAMLMetadataDocument=&SAMLProviderArn=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateSAMLProvider',
  qs: {SAMLMetadataDocument: '', SAMLProviderArn: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=UpdateSAMLProvider');

req.query({
  SAMLMetadataDocument: '',
  SAMLProviderArn: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateSAMLProvider',
  params: {SAMLMetadataDocument: '', SAMLProviderArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?SAMLMetadataDocument=&SAMLProviderArn=&Action=&Version=#Action=UpdateSAMLProvider';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?SAMLMetadataDocument=&SAMLProviderArn=&Action=&Version=#Action=UpdateSAMLProvider"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?SAMLMetadataDocument=&SAMLProviderArn=&Action=&Version=#Action=UpdateSAMLProvider" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?SAMLMetadataDocument=&SAMLProviderArn=&Action=&Version=#Action=UpdateSAMLProvider",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?SAMLMetadataDocument=&SAMLProviderArn=&Action=&Version=#Action=UpdateSAMLProvider');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UpdateSAMLProvider');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'SAMLMetadataDocument' => '',
  'SAMLProviderArn' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UpdateSAMLProvider');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'SAMLMetadataDocument' => '',
  'SAMLProviderArn' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?SAMLMetadataDocument=&SAMLProviderArn=&Action=&Version=#Action=UpdateSAMLProvider' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?SAMLMetadataDocument=&SAMLProviderArn=&Action=&Version=#Action=UpdateSAMLProvider' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?SAMLMetadataDocument=&SAMLProviderArn=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UpdateSAMLProvider"

querystring = {"SAMLMetadataDocument":"","SAMLProviderArn":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UpdateSAMLProvider"

queryString <- list(
  SAMLMetadataDocument = "",
  SAMLProviderArn = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?SAMLMetadataDocument=&SAMLProviderArn=&Action=&Version=#Action=UpdateSAMLProvider")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['SAMLMetadataDocument'] = ''
  req.params['SAMLProviderArn'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UpdateSAMLProvider";

    let querystring = [
        ("SAMLMetadataDocument", ""),
        ("SAMLProviderArn", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?SAMLMetadataDocument=&SAMLProviderArn=&Action=&Version=#Action=UpdateSAMLProvider'
http GET '{{baseUrl}}/?SAMLMetadataDocument=&SAMLProviderArn=&Action=&Version=#Action=UpdateSAMLProvider'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?SAMLMetadataDocument=&SAMLProviderArn=&Action=&Version=#Action=UpdateSAMLProvider'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?SAMLMetadataDocument=&SAMLProviderArn=&Action=&Version=#Action=UpdateSAMLProvider")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_UpdateSSHPublicKey
{{baseUrl}}/#Action=UpdateSSHPublicKey
QUERY PARAMS
UserName
SSHPublicKeyId
Status
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?UserName=&SSHPublicKeyId=&Status=&Action=&Version=#Action=UpdateSSHPublicKey");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=UpdateSSHPublicKey" {:query-params {:UserName ""
                                                                                     :SSHPublicKeyId ""
                                                                                     :Status ""
                                                                                     :Action ""
                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?UserName=&SSHPublicKeyId=&Status=&Action=&Version=#Action=UpdateSSHPublicKey"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?UserName=&SSHPublicKeyId=&Status=&Action=&Version=#Action=UpdateSSHPublicKey"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?UserName=&SSHPublicKeyId=&Status=&Action=&Version=#Action=UpdateSSHPublicKey");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?UserName=&SSHPublicKeyId=&Status=&Action=&Version=#Action=UpdateSSHPublicKey"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?UserName=&SSHPublicKeyId=&Status=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?UserName=&SSHPublicKeyId=&Status=&Action=&Version=#Action=UpdateSSHPublicKey")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?UserName=&SSHPublicKeyId=&Status=&Action=&Version=#Action=UpdateSSHPublicKey"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?UserName=&SSHPublicKeyId=&Status=&Action=&Version=#Action=UpdateSSHPublicKey")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?UserName=&SSHPublicKeyId=&Status=&Action=&Version=#Action=UpdateSSHPublicKey")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Status=&Action=&Version=#Action=UpdateSSHPublicKey');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateSSHPublicKey',
  params: {UserName: '', SSHPublicKeyId: '', Status: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Status=&Action=&Version=#Action=UpdateSSHPublicKey';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Status=&Action=&Version=#Action=UpdateSSHPublicKey',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?UserName=&SSHPublicKeyId=&Status=&Action=&Version=#Action=UpdateSSHPublicKey")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?UserName=&SSHPublicKeyId=&Status=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateSSHPublicKey',
  qs: {UserName: '', SSHPublicKeyId: '', Status: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=UpdateSSHPublicKey');

req.query({
  UserName: '',
  SSHPublicKeyId: '',
  Status: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateSSHPublicKey',
  params: {UserName: '', SSHPublicKeyId: '', Status: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Status=&Action=&Version=#Action=UpdateSSHPublicKey';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?UserName=&SSHPublicKeyId=&Status=&Action=&Version=#Action=UpdateSSHPublicKey"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?UserName=&SSHPublicKeyId=&Status=&Action=&Version=#Action=UpdateSSHPublicKey" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?UserName=&SSHPublicKeyId=&Status=&Action=&Version=#Action=UpdateSSHPublicKey",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Status=&Action=&Version=#Action=UpdateSSHPublicKey');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UpdateSSHPublicKey');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'UserName' => '',
  'SSHPublicKeyId' => '',
  'Status' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UpdateSSHPublicKey');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'UserName' => '',
  'SSHPublicKeyId' => '',
  'Status' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Status=&Action=&Version=#Action=UpdateSSHPublicKey' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Status=&Action=&Version=#Action=UpdateSSHPublicKey' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?UserName=&SSHPublicKeyId=&Status=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UpdateSSHPublicKey"

querystring = {"UserName":"","SSHPublicKeyId":"","Status":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UpdateSSHPublicKey"

queryString <- list(
  UserName = "",
  SSHPublicKeyId = "",
  Status = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?UserName=&SSHPublicKeyId=&Status=&Action=&Version=#Action=UpdateSSHPublicKey")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['UserName'] = ''
  req.params['SSHPublicKeyId'] = ''
  req.params['Status'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UpdateSSHPublicKey";

    let querystring = [
        ("UserName", ""),
        ("SSHPublicKeyId", ""),
        ("Status", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Status=&Action=&Version=#Action=UpdateSSHPublicKey'
http GET '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Status=&Action=&Version=#Action=UpdateSSHPublicKey'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?UserName=&SSHPublicKeyId=&Status=&Action=&Version=#Action=UpdateSSHPublicKey'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?UserName=&SSHPublicKeyId=&Status=&Action=&Version=#Action=UpdateSSHPublicKey")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_UpdateServerCertificate
{{baseUrl}}/#Action=UpdateServerCertificate
QUERY PARAMS
ServerCertificateName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=UpdateServerCertificate");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=UpdateServerCertificate" {:query-params {:ServerCertificateName ""
                                                                                          :Action ""
                                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=UpdateServerCertificate"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=UpdateServerCertificate"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=UpdateServerCertificate");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=UpdateServerCertificate"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?ServerCertificateName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=UpdateServerCertificate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=UpdateServerCertificate"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=UpdateServerCertificate")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=UpdateServerCertificate")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=UpdateServerCertificate');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateServerCertificate',
  params: {ServerCertificateName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=UpdateServerCertificate';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=UpdateServerCertificate',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=UpdateServerCertificate")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?ServerCertificateName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateServerCertificate',
  qs: {ServerCertificateName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=UpdateServerCertificate');

req.query({
  ServerCertificateName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateServerCertificate',
  params: {ServerCertificateName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=UpdateServerCertificate';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=UpdateServerCertificate"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=UpdateServerCertificate" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=UpdateServerCertificate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=UpdateServerCertificate');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UpdateServerCertificate');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'ServerCertificateName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UpdateServerCertificate');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'ServerCertificateName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=UpdateServerCertificate' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=UpdateServerCertificate' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?ServerCertificateName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UpdateServerCertificate"

querystring = {"ServerCertificateName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UpdateServerCertificate"

queryString <- list(
  ServerCertificateName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=UpdateServerCertificate")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['ServerCertificateName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UpdateServerCertificate";

    let querystring = [
        ("ServerCertificateName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=UpdateServerCertificate'
http GET '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=UpdateServerCertificate'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=UpdateServerCertificate'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?ServerCertificateName=&Action=&Version=#Action=UpdateServerCertificate")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_UpdateServiceSpecificCredential
{{baseUrl}}/#Action=UpdateServiceSpecificCredential
QUERY PARAMS
ServiceSpecificCredentialId
Status
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?ServiceSpecificCredentialId=&Status=&Action=&Version=#Action=UpdateServiceSpecificCredential");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=UpdateServiceSpecificCredential" {:query-params {:ServiceSpecificCredentialId ""
                                                                                                  :Status ""
                                                                                                  :Action ""
                                                                                                  :Version ""}})
require "http/client"

url = "{{baseUrl}}/?ServiceSpecificCredentialId=&Status=&Action=&Version=#Action=UpdateServiceSpecificCredential"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?ServiceSpecificCredentialId=&Status=&Action=&Version=#Action=UpdateServiceSpecificCredential"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?ServiceSpecificCredentialId=&Status=&Action=&Version=#Action=UpdateServiceSpecificCredential");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?ServiceSpecificCredentialId=&Status=&Action=&Version=#Action=UpdateServiceSpecificCredential"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?ServiceSpecificCredentialId=&Status=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?ServiceSpecificCredentialId=&Status=&Action=&Version=#Action=UpdateServiceSpecificCredential")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?ServiceSpecificCredentialId=&Status=&Action=&Version=#Action=UpdateServiceSpecificCredential"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?ServiceSpecificCredentialId=&Status=&Action=&Version=#Action=UpdateServiceSpecificCredential")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?ServiceSpecificCredentialId=&Status=&Action=&Version=#Action=UpdateServiceSpecificCredential")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?ServiceSpecificCredentialId=&Status=&Action=&Version=#Action=UpdateServiceSpecificCredential');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateServiceSpecificCredential',
  params: {ServiceSpecificCredentialId: '', Status: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?ServiceSpecificCredentialId=&Status=&Action=&Version=#Action=UpdateServiceSpecificCredential';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?ServiceSpecificCredentialId=&Status=&Action=&Version=#Action=UpdateServiceSpecificCredential',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?ServiceSpecificCredentialId=&Status=&Action=&Version=#Action=UpdateServiceSpecificCredential")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?ServiceSpecificCredentialId=&Status=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateServiceSpecificCredential',
  qs: {ServiceSpecificCredentialId: '', Status: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=UpdateServiceSpecificCredential');

req.query({
  ServiceSpecificCredentialId: '',
  Status: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateServiceSpecificCredential',
  params: {ServiceSpecificCredentialId: '', Status: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?ServiceSpecificCredentialId=&Status=&Action=&Version=#Action=UpdateServiceSpecificCredential';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?ServiceSpecificCredentialId=&Status=&Action=&Version=#Action=UpdateServiceSpecificCredential"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?ServiceSpecificCredentialId=&Status=&Action=&Version=#Action=UpdateServiceSpecificCredential" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?ServiceSpecificCredentialId=&Status=&Action=&Version=#Action=UpdateServiceSpecificCredential",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?ServiceSpecificCredentialId=&Status=&Action=&Version=#Action=UpdateServiceSpecificCredential');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UpdateServiceSpecificCredential');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'ServiceSpecificCredentialId' => '',
  'Status' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UpdateServiceSpecificCredential');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'ServiceSpecificCredentialId' => '',
  'Status' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?ServiceSpecificCredentialId=&Status=&Action=&Version=#Action=UpdateServiceSpecificCredential' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?ServiceSpecificCredentialId=&Status=&Action=&Version=#Action=UpdateServiceSpecificCredential' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?ServiceSpecificCredentialId=&Status=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UpdateServiceSpecificCredential"

querystring = {"ServiceSpecificCredentialId":"","Status":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UpdateServiceSpecificCredential"

queryString <- list(
  ServiceSpecificCredentialId = "",
  Status = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?ServiceSpecificCredentialId=&Status=&Action=&Version=#Action=UpdateServiceSpecificCredential")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['ServiceSpecificCredentialId'] = ''
  req.params['Status'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UpdateServiceSpecificCredential";

    let querystring = [
        ("ServiceSpecificCredentialId", ""),
        ("Status", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?ServiceSpecificCredentialId=&Status=&Action=&Version=#Action=UpdateServiceSpecificCredential'
http GET '{{baseUrl}}/?ServiceSpecificCredentialId=&Status=&Action=&Version=#Action=UpdateServiceSpecificCredential'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?ServiceSpecificCredentialId=&Status=&Action=&Version=#Action=UpdateServiceSpecificCredential'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?ServiceSpecificCredentialId=&Status=&Action=&Version=#Action=UpdateServiceSpecificCredential")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_UpdateSigningCertificate
{{baseUrl}}/#Action=UpdateSigningCertificate
QUERY PARAMS
CertificateId
Status
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?CertificateId=&Status=&Action=&Version=#Action=UpdateSigningCertificate");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=UpdateSigningCertificate" {:query-params {:CertificateId ""
                                                                                           :Status ""
                                                                                           :Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?CertificateId=&Status=&Action=&Version=#Action=UpdateSigningCertificate"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?CertificateId=&Status=&Action=&Version=#Action=UpdateSigningCertificate"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?CertificateId=&Status=&Action=&Version=#Action=UpdateSigningCertificate");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?CertificateId=&Status=&Action=&Version=#Action=UpdateSigningCertificate"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?CertificateId=&Status=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?CertificateId=&Status=&Action=&Version=#Action=UpdateSigningCertificate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?CertificateId=&Status=&Action=&Version=#Action=UpdateSigningCertificate"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?CertificateId=&Status=&Action=&Version=#Action=UpdateSigningCertificate")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?CertificateId=&Status=&Action=&Version=#Action=UpdateSigningCertificate")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?CertificateId=&Status=&Action=&Version=#Action=UpdateSigningCertificate');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateSigningCertificate',
  params: {CertificateId: '', Status: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?CertificateId=&Status=&Action=&Version=#Action=UpdateSigningCertificate';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?CertificateId=&Status=&Action=&Version=#Action=UpdateSigningCertificate',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?CertificateId=&Status=&Action=&Version=#Action=UpdateSigningCertificate")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?CertificateId=&Status=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateSigningCertificate',
  qs: {CertificateId: '', Status: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=UpdateSigningCertificate');

req.query({
  CertificateId: '',
  Status: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateSigningCertificate',
  params: {CertificateId: '', Status: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?CertificateId=&Status=&Action=&Version=#Action=UpdateSigningCertificate';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?CertificateId=&Status=&Action=&Version=#Action=UpdateSigningCertificate"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?CertificateId=&Status=&Action=&Version=#Action=UpdateSigningCertificate" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?CertificateId=&Status=&Action=&Version=#Action=UpdateSigningCertificate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?CertificateId=&Status=&Action=&Version=#Action=UpdateSigningCertificate');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UpdateSigningCertificate');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'CertificateId' => '',
  'Status' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UpdateSigningCertificate');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'CertificateId' => '',
  'Status' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?CertificateId=&Status=&Action=&Version=#Action=UpdateSigningCertificate' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?CertificateId=&Status=&Action=&Version=#Action=UpdateSigningCertificate' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?CertificateId=&Status=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UpdateSigningCertificate"

querystring = {"CertificateId":"","Status":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UpdateSigningCertificate"

queryString <- list(
  CertificateId = "",
  Status = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?CertificateId=&Status=&Action=&Version=#Action=UpdateSigningCertificate")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['CertificateId'] = ''
  req.params['Status'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UpdateSigningCertificate";

    let querystring = [
        ("CertificateId", ""),
        ("Status", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?CertificateId=&Status=&Action=&Version=#Action=UpdateSigningCertificate'
http GET '{{baseUrl}}/?CertificateId=&Status=&Action=&Version=#Action=UpdateSigningCertificate'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?CertificateId=&Status=&Action=&Version=#Action=UpdateSigningCertificate'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?CertificateId=&Status=&Action=&Version=#Action=UpdateSigningCertificate")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_UpdateUser
{{baseUrl}}/#Action=UpdateUser
QUERY PARAMS
UserName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateUser");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=UpdateUser" {:query-params {:UserName ""
                                                                             :Action ""
                                                                             :Version ""}})
require "http/client"

url = "{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateUser"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateUser"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateUser");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateUser"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?UserName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateUser")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateUser"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateUser")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateUser")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateUser');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateUser',
  params: {UserName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateUser';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateUser',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateUser")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?UserName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateUser',
  qs: {UserName: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=UpdateUser');

req.query({
  UserName: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UpdateUser',
  params: {UserName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateUser';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateUser"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateUser" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateUser",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateUser');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UpdateUser');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'UserName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UpdateUser');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'UserName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateUser' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateUser' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?UserName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UpdateUser"

querystring = {"UserName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UpdateUser"

queryString <- list(
  UserName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateUser")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['UserName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UpdateUser";

    let querystring = [
        ("UserName", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateUser'
http GET '{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateUser'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateUser'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?UserName=&Action=&Version=#Action=UpdateUser")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_UploadSSHPublicKey
{{baseUrl}}/#Action=UploadSSHPublicKey
QUERY PARAMS
UserName
SSHPublicKeyBody
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?UserName=&SSHPublicKeyBody=&Action=&Version=#Action=UploadSSHPublicKey");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=UploadSSHPublicKey" {:query-params {:UserName ""
                                                                                     :SSHPublicKeyBody ""
                                                                                     :Action ""
                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?UserName=&SSHPublicKeyBody=&Action=&Version=#Action=UploadSSHPublicKey"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?UserName=&SSHPublicKeyBody=&Action=&Version=#Action=UploadSSHPublicKey"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?UserName=&SSHPublicKeyBody=&Action=&Version=#Action=UploadSSHPublicKey");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?UserName=&SSHPublicKeyBody=&Action=&Version=#Action=UploadSSHPublicKey"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?UserName=&SSHPublicKeyBody=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?UserName=&SSHPublicKeyBody=&Action=&Version=#Action=UploadSSHPublicKey")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?UserName=&SSHPublicKeyBody=&Action=&Version=#Action=UploadSSHPublicKey"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?UserName=&SSHPublicKeyBody=&Action=&Version=#Action=UploadSSHPublicKey")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?UserName=&SSHPublicKeyBody=&Action=&Version=#Action=UploadSSHPublicKey")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?UserName=&SSHPublicKeyBody=&Action=&Version=#Action=UploadSSHPublicKey');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UploadSSHPublicKey',
  params: {UserName: '', SSHPublicKeyBody: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?UserName=&SSHPublicKeyBody=&Action=&Version=#Action=UploadSSHPublicKey';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?UserName=&SSHPublicKeyBody=&Action=&Version=#Action=UploadSSHPublicKey',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?UserName=&SSHPublicKeyBody=&Action=&Version=#Action=UploadSSHPublicKey")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?UserName=&SSHPublicKeyBody=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UploadSSHPublicKey',
  qs: {UserName: '', SSHPublicKeyBody: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=UploadSSHPublicKey');

req.query({
  UserName: '',
  SSHPublicKeyBody: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UploadSSHPublicKey',
  params: {UserName: '', SSHPublicKeyBody: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?UserName=&SSHPublicKeyBody=&Action=&Version=#Action=UploadSSHPublicKey';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?UserName=&SSHPublicKeyBody=&Action=&Version=#Action=UploadSSHPublicKey"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?UserName=&SSHPublicKeyBody=&Action=&Version=#Action=UploadSSHPublicKey" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?UserName=&SSHPublicKeyBody=&Action=&Version=#Action=UploadSSHPublicKey",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?UserName=&SSHPublicKeyBody=&Action=&Version=#Action=UploadSSHPublicKey');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UploadSSHPublicKey');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'UserName' => '',
  'SSHPublicKeyBody' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UploadSSHPublicKey');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'UserName' => '',
  'SSHPublicKeyBody' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?UserName=&SSHPublicKeyBody=&Action=&Version=#Action=UploadSSHPublicKey' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?UserName=&SSHPublicKeyBody=&Action=&Version=#Action=UploadSSHPublicKey' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?UserName=&SSHPublicKeyBody=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UploadSSHPublicKey"

querystring = {"UserName":"","SSHPublicKeyBody":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UploadSSHPublicKey"

queryString <- list(
  UserName = "",
  SSHPublicKeyBody = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?UserName=&SSHPublicKeyBody=&Action=&Version=#Action=UploadSSHPublicKey")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['UserName'] = ''
  req.params['SSHPublicKeyBody'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UploadSSHPublicKey";

    let querystring = [
        ("UserName", ""),
        ("SSHPublicKeyBody", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?UserName=&SSHPublicKeyBody=&Action=&Version=#Action=UploadSSHPublicKey'
http GET '{{baseUrl}}/?UserName=&SSHPublicKeyBody=&Action=&Version=#Action=UploadSSHPublicKey'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?UserName=&SSHPublicKeyBody=&Action=&Version=#Action=UploadSSHPublicKey'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?UserName=&SSHPublicKeyBody=&Action=&Version=#Action=UploadSSHPublicKey")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET GET_UploadServerCertificate
{{baseUrl}}/#Action=UploadServerCertificate
QUERY PARAMS
ServerCertificateName
CertificateBody
PrivateKey
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?ServerCertificateName=&CertificateBody=&PrivateKey=&Action=&Version=#Action=UploadServerCertificate");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=UploadServerCertificate" {:query-params {:ServerCertificateName ""
                                                                                          :CertificateBody ""
                                                                                          :PrivateKey ""
                                                                                          :Action ""
                                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?ServerCertificateName=&CertificateBody=&PrivateKey=&Action=&Version=#Action=UploadServerCertificate"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?ServerCertificateName=&CertificateBody=&PrivateKey=&Action=&Version=#Action=UploadServerCertificate"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?ServerCertificateName=&CertificateBody=&PrivateKey=&Action=&Version=#Action=UploadServerCertificate");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?ServerCertificateName=&CertificateBody=&PrivateKey=&Action=&Version=#Action=UploadServerCertificate"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?ServerCertificateName=&CertificateBody=&PrivateKey=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?ServerCertificateName=&CertificateBody=&PrivateKey=&Action=&Version=#Action=UploadServerCertificate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?ServerCertificateName=&CertificateBody=&PrivateKey=&Action=&Version=#Action=UploadServerCertificate"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?ServerCertificateName=&CertificateBody=&PrivateKey=&Action=&Version=#Action=UploadServerCertificate")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?ServerCertificateName=&CertificateBody=&PrivateKey=&Action=&Version=#Action=UploadServerCertificate")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?ServerCertificateName=&CertificateBody=&PrivateKey=&Action=&Version=#Action=UploadServerCertificate');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UploadServerCertificate',
  params: {
    ServerCertificateName: '',
    CertificateBody: '',
    PrivateKey: '',
    Action: '',
    Version: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?ServerCertificateName=&CertificateBody=&PrivateKey=&Action=&Version=#Action=UploadServerCertificate';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?ServerCertificateName=&CertificateBody=&PrivateKey=&Action=&Version=#Action=UploadServerCertificate',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?ServerCertificateName=&CertificateBody=&PrivateKey=&Action=&Version=#Action=UploadServerCertificate")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?ServerCertificateName=&CertificateBody=&PrivateKey=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UploadServerCertificate',
  qs: {
    ServerCertificateName: '',
    CertificateBody: '',
    PrivateKey: '',
    Action: '',
    Version: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=UploadServerCertificate');

req.query({
  ServerCertificateName: '',
  CertificateBody: '',
  PrivateKey: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UploadServerCertificate',
  params: {
    ServerCertificateName: '',
    CertificateBody: '',
    PrivateKey: '',
    Action: '',
    Version: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?ServerCertificateName=&CertificateBody=&PrivateKey=&Action=&Version=#Action=UploadServerCertificate';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?ServerCertificateName=&CertificateBody=&PrivateKey=&Action=&Version=#Action=UploadServerCertificate"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?ServerCertificateName=&CertificateBody=&PrivateKey=&Action=&Version=#Action=UploadServerCertificate" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?ServerCertificateName=&CertificateBody=&PrivateKey=&Action=&Version=#Action=UploadServerCertificate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?ServerCertificateName=&CertificateBody=&PrivateKey=&Action=&Version=#Action=UploadServerCertificate');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UploadServerCertificate');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'ServerCertificateName' => '',
  'CertificateBody' => '',
  'PrivateKey' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UploadServerCertificate');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'ServerCertificateName' => '',
  'CertificateBody' => '',
  'PrivateKey' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?ServerCertificateName=&CertificateBody=&PrivateKey=&Action=&Version=#Action=UploadServerCertificate' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?ServerCertificateName=&CertificateBody=&PrivateKey=&Action=&Version=#Action=UploadServerCertificate' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?ServerCertificateName=&CertificateBody=&PrivateKey=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UploadServerCertificate"

querystring = {"ServerCertificateName":"","CertificateBody":"","PrivateKey":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UploadServerCertificate"

queryString <- list(
  ServerCertificateName = "",
  CertificateBody = "",
  PrivateKey = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?ServerCertificateName=&CertificateBody=&PrivateKey=&Action=&Version=#Action=UploadServerCertificate")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['ServerCertificateName'] = ''
  req.params['CertificateBody'] = ''
  req.params['PrivateKey'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UploadServerCertificate";

    let querystring = [
        ("ServerCertificateName", ""),
        ("CertificateBody", ""),
        ("PrivateKey", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?ServerCertificateName=&CertificateBody=&PrivateKey=&Action=&Version=#Action=UploadServerCertificate'
http GET '{{baseUrl}}/?ServerCertificateName=&CertificateBody=&PrivateKey=&Action=&Version=#Action=UploadServerCertificate'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?ServerCertificateName=&CertificateBody=&PrivateKey=&Action=&Version=#Action=UploadServerCertificate'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?ServerCertificateName=&CertificateBody=&PrivateKey=&Action=&Version=#Action=UploadServerCertificate")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "ServerCertificateMetadata": {
    "Arn": "arn:aws:iam::123456789012:server-certificate/company/servercerts/ProdServerCert",
    "Expiration": "2012-05-08T01:02:03.004Z",
    "Path": "/company/servercerts/",
    "ServerCertificateId": "ASCA1111111111EXAMPLE",
    "ServerCertificateName": "ProdServerCert",
    "UploadDate": "2010-05-08T01:02:03.004Z"
  }
}
GET GET_UploadSigningCertificate
{{baseUrl}}/#Action=UploadSigningCertificate
QUERY PARAMS
CertificateBody
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?CertificateBody=&Action=&Version=#Action=UploadSigningCertificate");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=UploadSigningCertificate" {:query-params {:CertificateBody ""
                                                                                           :Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?CertificateBody=&Action=&Version=#Action=UploadSigningCertificate"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/?CertificateBody=&Action=&Version=#Action=UploadSigningCertificate"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?CertificateBody=&Action=&Version=#Action=UploadSigningCertificate");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?CertificateBody=&Action=&Version=#Action=UploadSigningCertificate"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/?CertificateBody=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?CertificateBody=&Action=&Version=#Action=UploadSigningCertificate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?CertificateBody=&Action=&Version=#Action=UploadSigningCertificate"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/?CertificateBody=&Action=&Version=#Action=UploadSigningCertificate")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?CertificateBody=&Action=&Version=#Action=UploadSigningCertificate")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/?CertificateBody=&Action=&Version=#Action=UploadSigningCertificate');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UploadSigningCertificate',
  params: {CertificateBody: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?CertificateBody=&Action=&Version=#Action=UploadSigningCertificate';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/?CertificateBody=&Action=&Version=#Action=UploadSigningCertificate',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?CertificateBody=&Action=&Version=#Action=UploadSigningCertificate")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?CertificateBody=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UploadSigningCertificate',
  qs: {CertificateBody: '', Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/#Action=UploadSigningCertificate');

req.query({
  CertificateBody: '',
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=UploadSigningCertificate',
  params: {CertificateBody: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?CertificateBody=&Action=&Version=#Action=UploadSigningCertificate';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/?CertificateBody=&Action=&Version=#Action=UploadSigningCertificate"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/?CertificateBody=&Action=&Version=#Action=UploadSigningCertificate" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?CertificateBody=&Action=&Version=#Action=UploadSigningCertificate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/?CertificateBody=&Action=&Version=#Action=UploadSigningCertificate');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UploadSigningCertificate');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'CertificateBody' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UploadSigningCertificate');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'CertificateBody' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?CertificateBody=&Action=&Version=#Action=UploadSigningCertificate' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?CertificateBody=&Action=&Version=#Action=UploadSigningCertificate' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?CertificateBody=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UploadSigningCertificate"

querystring = {"CertificateBody":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UploadSigningCertificate"

queryString <- list(
  CertificateBody = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?CertificateBody=&Action=&Version=#Action=UploadSigningCertificate")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/') do |req|
  req.params['CertificateBody'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UploadSigningCertificate";

    let querystring = [
        ("CertificateBody", ""),
        ("Action", ""),
        ("Version", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/?CertificateBody=&Action=&Version=#Action=UploadSigningCertificate'
http GET '{{baseUrl}}/?CertificateBody=&Action=&Version=#Action=UploadSigningCertificate'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?CertificateBody=&Action=&Version=#Action=UploadSigningCertificate'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?CertificateBody=&Action=&Version=#Action=UploadSigningCertificate")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "Certificate": {
    "CertificateBody": "-----BEGIN CERTIFICATE----------END CERTIFICATE-----",
    "CertificateId": "ID123456789012345EXAMPLE",
    "Status": "Active",
    "UploadDate": "2015-06-06T21:40:08.121Z",
    "UserName": "Bob"
  }
}
POST POST_AddClientIDToOpenIDConnectProvider
{{baseUrl}}/#Action=AddClientIDToOpenIDConnectProvider
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=AddClientIDToOpenIDConnectProvider");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=AddClientIDToOpenIDConnectProvider" {:query-params {:Action ""
                                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=AddClientIDToOpenIDConnectProvider"

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}}/?Action=&Version=#Action=AddClientIDToOpenIDConnectProvider"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=AddClientIDToOpenIDConnectProvider");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=AddClientIDToOpenIDConnectProvider"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=AddClientIDToOpenIDConnectProvider")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=AddClientIDToOpenIDConnectProvider"))
    .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}}/?Action=&Version=#Action=AddClientIDToOpenIDConnectProvider")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=AddClientIDToOpenIDConnectProvider")
  .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}}/?Action=&Version=#Action=AddClientIDToOpenIDConnectProvider');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=AddClientIDToOpenIDConnectProvider',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=AddClientIDToOpenIDConnectProvider';
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}}/?Action=&Version=#Action=AddClientIDToOpenIDConnectProvider',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=AddClientIDToOpenIDConnectProvider")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=AddClientIDToOpenIDConnectProvider',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=AddClientIDToOpenIDConnectProvider');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=AddClientIDToOpenIDConnectProvider',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=AddClientIDToOpenIDConnectProvider';
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}}/?Action=&Version=#Action=AddClientIDToOpenIDConnectProvider"]
                                                       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}}/?Action=&Version=#Action=AddClientIDToOpenIDConnectProvider" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=AddClientIDToOpenIDConnectProvider",
  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}}/?Action=&Version=#Action=AddClientIDToOpenIDConnectProvider');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=AddClientIDToOpenIDConnectProvider');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=AddClientIDToOpenIDConnectProvider');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=AddClientIDToOpenIDConnectProvider' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=AddClientIDToOpenIDConnectProvider' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=AddClientIDToOpenIDConnectProvider"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=AddClientIDToOpenIDConnectProvider"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=AddClientIDToOpenIDConnectProvider")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=AddClientIDToOpenIDConnectProvider";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=AddClientIDToOpenIDConnectProvider'
http POST '{{baseUrl}}/?Action=&Version=#Action=AddClientIDToOpenIDConnectProvider'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=AddClientIDToOpenIDConnectProvider'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=AddClientIDToOpenIDConnectProvider")! 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 POST_AddRoleToInstanceProfile
{{baseUrl}}/#Action=AddRoleToInstanceProfile
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=AddRoleToInstanceProfile");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=AddRoleToInstanceProfile" {:query-params {:Action ""
                                                                                            :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=AddRoleToInstanceProfile"

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}}/?Action=&Version=#Action=AddRoleToInstanceProfile"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=AddRoleToInstanceProfile");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=AddRoleToInstanceProfile"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=AddRoleToInstanceProfile")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=AddRoleToInstanceProfile"))
    .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}}/?Action=&Version=#Action=AddRoleToInstanceProfile")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=AddRoleToInstanceProfile")
  .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}}/?Action=&Version=#Action=AddRoleToInstanceProfile');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=AddRoleToInstanceProfile',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=AddRoleToInstanceProfile';
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}}/?Action=&Version=#Action=AddRoleToInstanceProfile',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=AddRoleToInstanceProfile")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=AddRoleToInstanceProfile',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=AddRoleToInstanceProfile');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=AddRoleToInstanceProfile',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=AddRoleToInstanceProfile';
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}}/?Action=&Version=#Action=AddRoleToInstanceProfile"]
                                                       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}}/?Action=&Version=#Action=AddRoleToInstanceProfile" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=AddRoleToInstanceProfile",
  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}}/?Action=&Version=#Action=AddRoleToInstanceProfile');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=AddRoleToInstanceProfile');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=AddRoleToInstanceProfile');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=AddRoleToInstanceProfile' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=AddRoleToInstanceProfile' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=AddRoleToInstanceProfile"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=AddRoleToInstanceProfile"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=AddRoleToInstanceProfile")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=AddRoleToInstanceProfile";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=AddRoleToInstanceProfile'
http POST '{{baseUrl}}/?Action=&Version=#Action=AddRoleToInstanceProfile'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=AddRoleToInstanceProfile'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=AddRoleToInstanceProfile")! 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 POST_AddUserToGroup
{{baseUrl}}/#Action=AddUserToGroup
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=AddUserToGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=AddUserToGroup" {:query-params {:Action ""
                                                                                  :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=AddUserToGroup"

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}}/?Action=&Version=#Action=AddUserToGroup"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=AddUserToGroup");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=AddUserToGroup"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=AddUserToGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=AddUserToGroup"))
    .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}}/?Action=&Version=#Action=AddUserToGroup")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=AddUserToGroup")
  .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}}/?Action=&Version=#Action=AddUserToGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=AddUserToGroup',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=AddUserToGroup';
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}}/?Action=&Version=#Action=AddUserToGroup',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=AddUserToGroup")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=AddUserToGroup',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=AddUserToGroup');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=AddUserToGroup',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=AddUserToGroup';
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}}/?Action=&Version=#Action=AddUserToGroup"]
                                                       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}}/?Action=&Version=#Action=AddUserToGroup" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=AddUserToGroup",
  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}}/?Action=&Version=#Action=AddUserToGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=AddUserToGroup');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=AddUserToGroup');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=AddUserToGroup' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=AddUserToGroup' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=AddUserToGroup"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=AddUserToGroup"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=AddUserToGroup")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=AddUserToGroup";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=AddUserToGroup'
http POST '{{baseUrl}}/?Action=&Version=#Action=AddUserToGroup'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=AddUserToGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=AddUserToGroup")! 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 POST_AttachGroupPolicy
{{baseUrl}}/#Action=AttachGroupPolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=AttachGroupPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=AttachGroupPolicy" {:query-params {:Action ""
                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=AttachGroupPolicy"

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}}/?Action=&Version=#Action=AttachGroupPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=AttachGroupPolicy");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=AttachGroupPolicy"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=AttachGroupPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=AttachGroupPolicy"))
    .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}}/?Action=&Version=#Action=AttachGroupPolicy")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=AttachGroupPolicy")
  .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}}/?Action=&Version=#Action=AttachGroupPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=AttachGroupPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=AttachGroupPolicy';
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}}/?Action=&Version=#Action=AttachGroupPolicy',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=AttachGroupPolicy")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=AttachGroupPolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=AttachGroupPolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=AttachGroupPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=AttachGroupPolicy';
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}}/?Action=&Version=#Action=AttachGroupPolicy"]
                                                       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}}/?Action=&Version=#Action=AttachGroupPolicy" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=AttachGroupPolicy",
  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}}/?Action=&Version=#Action=AttachGroupPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=AttachGroupPolicy');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=AttachGroupPolicy');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=AttachGroupPolicy' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=AttachGroupPolicy' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=AttachGroupPolicy"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=AttachGroupPolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=AttachGroupPolicy")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=AttachGroupPolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=AttachGroupPolicy'
http POST '{{baseUrl}}/?Action=&Version=#Action=AttachGroupPolicy'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=AttachGroupPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=AttachGroupPolicy")! 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 POST_AttachRolePolicy
{{baseUrl}}/#Action=AttachRolePolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=AttachRolePolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=AttachRolePolicy" {:query-params {:Action ""
                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=AttachRolePolicy"

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}}/?Action=&Version=#Action=AttachRolePolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=AttachRolePolicy");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=AttachRolePolicy"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=AttachRolePolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=AttachRolePolicy"))
    .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}}/?Action=&Version=#Action=AttachRolePolicy")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=AttachRolePolicy")
  .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}}/?Action=&Version=#Action=AttachRolePolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=AttachRolePolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=AttachRolePolicy';
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}}/?Action=&Version=#Action=AttachRolePolicy',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=AttachRolePolicy")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=AttachRolePolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=AttachRolePolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=AttachRolePolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=AttachRolePolicy';
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}}/?Action=&Version=#Action=AttachRolePolicy"]
                                                       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}}/?Action=&Version=#Action=AttachRolePolicy" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=AttachRolePolicy",
  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}}/?Action=&Version=#Action=AttachRolePolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=AttachRolePolicy');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=AttachRolePolicy');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=AttachRolePolicy' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=AttachRolePolicy' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=AttachRolePolicy"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=AttachRolePolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=AttachRolePolicy")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=AttachRolePolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=AttachRolePolicy'
http POST '{{baseUrl}}/?Action=&Version=#Action=AttachRolePolicy'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=AttachRolePolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=AttachRolePolicy")! 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 POST_AttachUserPolicy
{{baseUrl}}/#Action=AttachUserPolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=AttachUserPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=AttachUserPolicy" {:query-params {:Action ""
                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=AttachUserPolicy"

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}}/?Action=&Version=#Action=AttachUserPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=AttachUserPolicy");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=AttachUserPolicy"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=AttachUserPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=AttachUserPolicy"))
    .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}}/?Action=&Version=#Action=AttachUserPolicy")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=AttachUserPolicy")
  .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}}/?Action=&Version=#Action=AttachUserPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=AttachUserPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=AttachUserPolicy';
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}}/?Action=&Version=#Action=AttachUserPolicy',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=AttachUserPolicy")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=AttachUserPolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=AttachUserPolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=AttachUserPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=AttachUserPolicy';
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}}/?Action=&Version=#Action=AttachUserPolicy"]
                                                       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}}/?Action=&Version=#Action=AttachUserPolicy" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=AttachUserPolicy",
  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}}/?Action=&Version=#Action=AttachUserPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=AttachUserPolicy');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=AttachUserPolicy');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=AttachUserPolicy' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=AttachUserPolicy' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=AttachUserPolicy"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=AttachUserPolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=AttachUserPolicy")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=AttachUserPolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=AttachUserPolicy'
http POST '{{baseUrl}}/?Action=&Version=#Action=AttachUserPolicy'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=AttachUserPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=AttachUserPolicy")! 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 POST_ChangePassword
{{baseUrl}}/#Action=ChangePassword
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ChangePassword");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ChangePassword" {:query-params {:Action ""
                                                                                  :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ChangePassword"

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}}/?Action=&Version=#Action=ChangePassword"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ChangePassword");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ChangePassword"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ChangePassword")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ChangePassword"))
    .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}}/?Action=&Version=#Action=ChangePassword")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ChangePassword")
  .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}}/?Action=&Version=#Action=ChangePassword');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ChangePassword',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ChangePassword';
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}}/?Action=&Version=#Action=ChangePassword',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ChangePassword")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ChangePassword',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ChangePassword');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ChangePassword',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ChangePassword';
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}}/?Action=&Version=#Action=ChangePassword"]
                                                       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}}/?Action=&Version=#Action=ChangePassword" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ChangePassword",
  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}}/?Action=&Version=#Action=ChangePassword');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ChangePassword');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ChangePassword');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ChangePassword' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ChangePassword' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ChangePassword"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ChangePassword"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ChangePassword")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ChangePassword";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ChangePassword'
http POST '{{baseUrl}}/?Action=&Version=#Action=ChangePassword'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ChangePassword'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ChangePassword")! 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 POST_CreateAccessKey
{{baseUrl}}/#Action=CreateAccessKey
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=CreateAccessKey" {:query-params {:Action ""
                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey"

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}}/?Action=&Version=#Action=CreateAccessKey"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey"))
    .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}}/?Action=&Version=#Action=CreateAccessKey")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey")
  .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}}/?Action=&Version=#Action=CreateAccessKey');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateAccessKey',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey';
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}}/?Action=&Version=#Action=CreateAccessKey',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=CreateAccessKey',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=CreateAccessKey');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateAccessKey',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey';
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}}/?Action=&Version=#Action=CreateAccessKey"]
                                                       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}}/?Action=&Version=#Action=CreateAccessKey" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateAccessKey');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateAccessKey');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/?Action=&Version=", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=CreateAccessKey"

querystring = {"Action":"","Version":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateAccessKey"

queryString <- list(
  Action = "",
  Version = ""
)

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=CreateAccessKey";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=CreateAccessKey'
http POST '{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=CreateAccessKey")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "AccessKey": {
    "AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
    "CreateDate": "2015-03-09T18:39:23.411Z",
    "SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYzEXAMPLEKEY",
    "Status": "Active",
    "UserName": "Bob"
  }
}
POST POST_CreateAccountAlias
{{baseUrl}}/#Action=CreateAccountAlias
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=CreateAccountAlias");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=CreateAccountAlias" {:query-params {:Action ""
                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=CreateAccountAlias"

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}}/?Action=&Version=#Action=CreateAccountAlias"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=CreateAccountAlias");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=CreateAccountAlias"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=CreateAccountAlias")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=CreateAccountAlias"))
    .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}}/?Action=&Version=#Action=CreateAccountAlias")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=CreateAccountAlias")
  .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}}/?Action=&Version=#Action=CreateAccountAlias');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateAccountAlias',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=CreateAccountAlias';
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}}/?Action=&Version=#Action=CreateAccountAlias',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=CreateAccountAlias")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=CreateAccountAlias',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=CreateAccountAlias');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateAccountAlias',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=CreateAccountAlias';
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}}/?Action=&Version=#Action=CreateAccountAlias"]
                                                       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}}/?Action=&Version=#Action=CreateAccountAlias" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=CreateAccountAlias",
  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}}/?Action=&Version=#Action=CreateAccountAlias');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateAccountAlias');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateAccountAlias');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateAccountAlias' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateAccountAlias' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=CreateAccountAlias"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateAccountAlias"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=CreateAccountAlias")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=CreateAccountAlias";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=CreateAccountAlias'
http POST '{{baseUrl}}/?Action=&Version=#Action=CreateAccountAlias'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=CreateAccountAlias'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=CreateAccountAlias")! 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 POST_CreateGroup
{{baseUrl}}/#Action=CreateGroup
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=CreateGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=CreateGroup" {:query-params {:Action ""
                                                                               :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=CreateGroup"

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}}/?Action=&Version=#Action=CreateGroup"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=CreateGroup");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=CreateGroup"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=CreateGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=CreateGroup"))
    .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}}/?Action=&Version=#Action=CreateGroup")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=CreateGroup")
  .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}}/?Action=&Version=#Action=CreateGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateGroup',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=CreateGroup';
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}}/?Action=&Version=#Action=CreateGroup',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=CreateGroup")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=CreateGroup',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=CreateGroup');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateGroup',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=CreateGroup';
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}}/?Action=&Version=#Action=CreateGroup"]
                                                       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}}/?Action=&Version=#Action=CreateGroup" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=CreateGroup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/?Action=&Version=#Action=CreateGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateGroup');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateGroup');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateGroup' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateGroup' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/?Action=&Version=", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=CreateGroup"

querystring = {"Action":"","Version":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateGroup"

queryString <- list(
  Action = "",
  Version = ""
)

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=CreateGroup")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=CreateGroup";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=CreateGroup'
http POST '{{baseUrl}}/?Action=&Version=#Action=CreateGroup'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=CreateGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=CreateGroup")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "Group": {
    "Arn": "arn:aws:iam::123456789012:group/Admins",
    "CreateDate": "2015-03-09T20:30:24.940Z",
    "GroupId": "AIDGPMS9RO4H3FEXAMPLE",
    "GroupName": "Admins",
    "Path": "/"
  }
}
POST POST_CreateInstanceProfile
{{baseUrl}}/#Action=CreateInstanceProfile
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=CreateInstanceProfile");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=CreateInstanceProfile" {:query-params {:Action ""
                                                                                         :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=CreateInstanceProfile"

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}}/?Action=&Version=#Action=CreateInstanceProfile"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=CreateInstanceProfile");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=CreateInstanceProfile"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=CreateInstanceProfile")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=CreateInstanceProfile"))
    .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}}/?Action=&Version=#Action=CreateInstanceProfile")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=CreateInstanceProfile")
  .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}}/?Action=&Version=#Action=CreateInstanceProfile');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateInstanceProfile',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=CreateInstanceProfile';
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}}/?Action=&Version=#Action=CreateInstanceProfile',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=CreateInstanceProfile")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=CreateInstanceProfile',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=CreateInstanceProfile');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateInstanceProfile',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=CreateInstanceProfile';
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}}/?Action=&Version=#Action=CreateInstanceProfile"]
                                                       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}}/?Action=&Version=#Action=CreateInstanceProfile" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=CreateInstanceProfile",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/?Action=&Version=#Action=CreateInstanceProfile');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateInstanceProfile');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateInstanceProfile');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateInstanceProfile' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateInstanceProfile' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/?Action=&Version=", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=CreateInstanceProfile"

querystring = {"Action":"","Version":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateInstanceProfile"

queryString <- list(
  Action = "",
  Version = ""
)

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=CreateInstanceProfile")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=CreateInstanceProfile";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=CreateInstanceProfile'
http POST '{{baseUrl}}/?Action=&Version=#Action=CreateInstanceProfile'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=CreateInstanceProfile'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=CreateInstanceProfile")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "InstanceProfile": {
    "Arn": "arn:aws:iam::123456789012:instance-profile/Webserver",
    "CreateDate": "2015-03-09T20:33:19.626Z",
    "InstanceProfileId": "AIPAJMBYC7DLSPEXAMPLE",
    "InstanceProfileName": "Webserver",
    "Path": "/",
    "Roles": []
  }
}
POST POST_CreateLoginProfile
{{baseUrl}}/#Action=CreateLoginProfile
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=CreateLoginProfile");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=CreateLoginProfile" {:query-params {:Action ""
                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=CreateLoginProfile"

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}}/?Action=&Version=#Action=CreateLoginProfile"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=CreateLoginProfile");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=CreateLoginProfile"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=CreateLoginProfile")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=CreateLoginProfile"))
    .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}}/?Action=&Version=#Action=CreateLoginProfile")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=CreateLoginProfile")
  .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}}/?Action=&Version=#Action=CreateLoginProfile');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateLoginProfile',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=CreateLoginProfile';
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}}/?Action=&Version=#Action=CreateLoginProfile',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=CreateLoginProfile")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=CreateLoginProfile',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=CreateLoginProfile');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateLoginProfile',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=CreateLoginProfile';
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}}/?Action=&Version=#Action=CreateLoginProfile"]
                                                       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}}/?Action=&Version=#Action=CreateLoginProfile" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=CreateLoginProfile",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/?Action=&Version=#Action=CreateLoginProfile');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateLoginProfile');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateLoginProfile');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateLoginProfile' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateLoginProfile' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/?Action=&Version=", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=CreateLoginProfile"

querystring = {"Action":"","Version":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateLoginProfile"

queryString <- list(
  Action = "",
  Version = ""
)

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=CreateLoginProfile")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=CreateLoginProfile";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=CreateLoginProfile'
http POST '{{baseUrl}}/?Action=&Version=#Action=CreateLoginProfile'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=CreateLoginProfile'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=CreateLoginProfile")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "LoginProfile": {
    "CreateDate": "2015-03-10T20:55:40.274Z",
    "PasswordResetRequired": true,
    "UserName": "Bob"
  }
}
POST POST_CreateOpenIDConnectProvider
{{baseUrl}}/#Action=CreateOpenIDConnectProvider
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=CreateOpenIDConnectProvider");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=CreateOpenIDConnectProvider" {:query-params {:Action ""
                                                                                               :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=CreateOpenIDConnectProvider"

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}}/?Action=&Version=#Action=CreateOpenIDConnectProvider"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=CreateOpenIDConnectProvider");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=CreateOpenIDConnectProvider"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=CreateOpenIDConnectProvider")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=CreateOpenIDConnectProvider"))
    .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}}/?Action=&Version=#Action=CreateOpenIDConnectProvider")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=CreateOpenIDConnectProvider")
  .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}}/?Action=&Version=#Action=CreateOpenIDConnectProvider');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateOpenIDConnectProvider',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=CreateOpenIDConnectProvider';
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}}/?Action=&Version=#Action=CreateOpenIDConnectProvider',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=CreateOpenIDConnectProvider")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=CreateOpenIDConnectProvider',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=CreateOpenIDConnectProvider');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateOpenIDConnectProvider',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=CreateOpenIDConnectProvider';
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}}/?Action=&Version=#Action=CreateOpenIDConnectProvider"]
                                                       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}}/?Action=&Version=#Action=CreateOpenIDConnectProvider" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=CreateOpenIDConnectProvider",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/?Action=&Version=#Action=CreateOpenIDConnectProvider');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateOpenIDConnectProvider');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateOpenIDConnectProvider');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateOpenIDConnectProvider' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateOpenIDConnectProvider' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/?Action=&Version=", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=CreateOpenIDConnectProvider"

querystring = {"Action":"","Version":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateOpenIDConnectProvider"

queryString <- list(
  Action = "",
  Version = ""
)

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=CreateOpenIDConnectProvider")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=CreateOpenIDConnectProvider";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=CreateOpenIDConnectProvider'
http POST '{{baseUrl}}/?Action=&Version=#Action=CreateOpenIDConnectProvider'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=CreateOpenIDConnectProvider'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=CreateOpenIDConnectProvider")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "OpenIDConnectProviderArn": "arn:aws:iam::123456789012:oidc-provider/server.example.com"
}
POST POST_CreatePolicy
{{baseUrl}}/#Action=CreatePolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=CreatePolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=CreatePolicy" {:query-params {:Action ""
                                                                                :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=CreatePolicy"

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}}/?Action=&Version=#Action=CreatePolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=CreatePolicy");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=CreatePolicy"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=CreatePolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=CreatePolicy"))
    .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}}/?Action=&Version=#Action=CreatePolicy")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=CreatePolicy")
  .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}}/?Action=&Version=#Action=CreatePolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreatePolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=CreatePolicy';
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}}/?Action=&Version=#Action=CreatePolicy',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=CreatePolicy")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=CreatePolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=CreatePolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreatePolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=CreatePolicy';
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}}/?Action=&Version=#Action=CreatePolicy"]
                                                       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}}/?Action=&Version=#Action=CreatePolicy" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=CreatePolicy",
  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}}/?Action=&Version=#Action=CreatePolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreatePolicy');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreatePolicy');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=CreatePolicy' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=CreatePolicy' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=CreatePolicy"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreatePolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=CreatePolicy")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=CreatePolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=CreatePolicy'
http POST '{{baseUrl}}/?Action=&Version=#Action=CreatePolicy'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=CreatePolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=CreatePolicy")! 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 POST_CreatePolicyVersion
{{baseUrl}}/#Action=CreatePolicyVersion
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=CreatePolicyVersion");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=CreatePolicyVersion" {:query-params {:Action ""
                                                                                       :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=CreatePolicyVersion"

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}}/?Action=&Version=#Action=CreatePolicyVersion"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=CreatePolicyVersion");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=CreatePolicyVersion"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=CreatePolicyVersion")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=CreatePolicyVersion"))
    .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}}/?Action=&Version=#Action=CreatePolicyVersion")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=CreatePolicyVersion")
  .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}}/?Action=&Version=#Action=CreatePolicyVersion');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreatePolicyVersion',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=CreatePolicyVersion';
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}}/?Action=&Version=#Action=CreatePolicyVersion',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=CreatePolicyVersion")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=CreatePolicyVersion',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=CreatePolicyVersion');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreatePolicyVersion',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=CreatePolicyVersion';
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}}/?Action=&Version=#Action=CreatePolicyVersion"]
                                                       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}}/?Action=&Version=#Action=CreatePolicyVersion" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=CreatePolicyVersion",
  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}}/?Action=&Version=#Action=CreatePolicyVersion');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreatePolicyVersion');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreatePolicyVersion');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=CreatePolicyVersion' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=CreatePolicyVersion' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=CreatePolicyVersion"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreatePolicyVersion"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=CreatePolicyVersion")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=CreatePolicyVersion";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=CreatePolicyVersion'
http POST '{{baseUrl}}/?Action=&Version=#Action=CreatePolicyVersion'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=CreatePolicyVersion'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=CreatePolicyVersion")! 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 POST_CreateRole
{{baseUrl}}/#Action=CreateRole
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=CreateRole");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=CreateRole" {:query-params {:Action ""
                                                                              :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=CreateRole"

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}}/?Action=&Version=#Action=CreateRole"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=CreateRole");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=CreateRole"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=CreateRole")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=CreateRole"))
    .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}}/?Action=&Version=#Action=CreateRole")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=CreateRole")
  .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}}/?Action=&Version=#Action=CreateRole');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateRole',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=CreateRole';
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}}/?Action=&Version=#Action=CreateRole',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=CreateRole")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=CreateRole',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=CreateRole');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateRole',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=CreateRole';
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}}/?Action=&Version=#Action=CreateRole"]
                                                       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}}/?Action=&Version=#Action=CreateRole" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=CreateRole",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/?Action=&Version=#Action=CreateRole');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateRole');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateRole');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateRole' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateRole' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/?Action=&Version=", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=CreateRole"

querystring = {"Action":"","Version":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateRole"

queryString <- list(
  Action = "",
  Version = ""
)

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=CreateRole")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=CreateRole";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=CreateRole'
http POST '{{baseUrl}}/?Action=&Version=#Action=CreateRole'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=CreateRole'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=CreateRole")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "Role": {
    "Arn": "arn:aws:iam::123456789012:role/Test-Role",
    "AssumeRolePolicyDocument": "",
    "CreateDate": "2013-06-07T20:43:32.821Z",
    "Path": "/",
    "RoleId": "AKIAIOSFODNN7EXAMPLE",
    "RoleName": "Test-Role"
  }
}
POST POST_CreateSAMLProvider
{{baseUrl}}/#Action=CreateSAMLProvider
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=CreateSAMLProvider");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=CreateSAMLProvider" {:query-params {:Action ""
                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=CreateSAMLProvider"

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}}/?Action=&Version=#Action=CreateSAMLProvider"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=CreateSAMLProvider");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=CreateSAMLProvider"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=CreateSAMLProvider")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=CreateSAMLProvider"))
    .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}}/?Action=&Version=#Action=CreateSAMLProvider")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=CreateSAMLProvider")
  .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}}/?Action=&Version=#Action=CreateSAMLProvider');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateSAMLProvider',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=CreateSAMLProvider';
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}}/?Action=&Version=#Action=CreateSAMLProvider',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=CreateSAMLProvider")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=CreateSAMLProvider',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=CreateSAMLProvider');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateSAMLProvider',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=CreateSAMLProvider';
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}}/?Action=&Version=#Action=CreateSAMLProvider"]
                                                       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}}/?Action=&Version=#Action=CreateSAMLProvider" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=CreateSAMLProvider",
  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}}/?Action=&Version=#Action=CreateSAMLProvider');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateSAMLProvider');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateSAMLProvider');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateSAMLProvider' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateSAMLProvider' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=CreateSAMLProvider"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateSAMLProvider"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=CreateSAMLProvider")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=CreateSAMLProvider";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=CreateSAMLProvider'
http POST '{{baseUrl}}/?Action=&Version=#Action=CreateSAMLProvider'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=CreateSAMLProvider'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=CreateSAMLProvider")! 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 POST_CreateServiceLinkedRole
{{baseUrl}}/#Action=CreateServiceLinkedRole
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=CreateServiceLinkedRole");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=CreateServiceLinkedRole" {:query-params {:Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=CreateServiceLinkedRole"

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}}/?Action=&Version=#Action=CreateServiceLinkedRole"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=CreateServiceLinkedRole");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=CreateServiceLinkedRole"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=CreateServiceLinkedRole")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=CreateServiceLinkedRole"))
    .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}}/?Action=&Version=#Action=CreateServiceLinkedRole")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=CreateServiceLinkedRole")
  .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}}/?Action=&Version=#Action=CreateServiceLinkedRole');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateServiceLinkedRole',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=CreateServiceLinkedRole';
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}}/?Action=&Version=#Action=CreateServiceLinkedRole',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=CreateServiceLinkedRole")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=CreateServiceLinkedRole',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=CreateServiceLinkedRole');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateServiceLinkedRole',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=CreateServiceLinkedRole';
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}}/?Action=&Version=#Action=CreateServiceLinkedRole"]
                                                       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}}/?Action=&Version=#Action=CreateServiceLinkedRole" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=CreateServiceLinkedRole",
  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}}/?Action=&Version=#Action=CreateServiceLinkedRole');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateServiceLinkedRole');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateServiceLinkedRole');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateServiceLinkedRole' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateServiceLinkedRole' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=CreateServiceLinkedRole"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateServiceLinkedRole"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=CreateServiceLinkedRole")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=CreateServiceLinkedRole";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=CreateServiceLinkedRole'
http POST '{{baseUrl}}/?Action=&Version=#Action=CreateServiceLinkedRole'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=CreateServiceLinkedRole'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=CreateServiceLinkedRole")! 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 POST_CreateServiceSpecificCredential
{{baseUrl}}/#Action=CreateServiceSpecificCredential
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=CreateServiceSpecificCredential");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=CreateServiceSpecificCredential" {:query-params {:Action ""
                                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=CreateServiceSpecificCredential"

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}}/?Action=&Version=#Action=CreateServiceSpecificCredential"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=CreateServiceSpecificCredential");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=CreateServiceSpecificCredential"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=CreateServiceSpecificCredential")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=CreateServiceSpecificCredential"))
    .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}}/?Action=&Version=#Action=CreateServiceSpecificCredential")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=CreateServiceSpecificCredential")
  .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}}/?Action=&Version=#Action=CreateServiceSpecificCredential');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateServiceSpecificCredential',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=CreateServiceSpecificCredential';
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}}/?Action=&Version=#Action=CreateServiceSpecificCredential',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=CreateServiceSpecificCredential")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=CreateServiceSpecificCredential',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=CreateServiceSpecificCredential');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateServiceSpecificCredential',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=CreateServiceSpecificCredential';
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}}/?Action=&Version=#Action=CreateServiceSpecificCredential"]
                                                       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}}/?Action=&Version=#Action=CreateServiceSpecificCredential" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=CreateServiceSpecificCredential",
  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}}/?Action=&Version=#Action=CreateServiceSpecificCredential');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateServiceSpecificCredential');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateServiceSpecificCredential');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateServiceSpecificCredential' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateServiceSpecificCredential' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=CreateServiceSpecificCredential"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateServiceSpecificCredential"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=CreateServiceSpecificCredential")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=CreateServiceSpecificCredential";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=CreateServiceSpecificCredential'
http POST '{{baseUrl}}/?Action=&Version=#Action=CreateServiceSpecificCredential'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=CreateServiceSpecificCredential'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=CreateServiceSpecificCredential")! 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 POST_CreateUser
{{baseUrl}}/#Action=CreateUser
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=CreateUser");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=CreateUser" {:query-params {:Action ""
                                                                              :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=CreateUser"

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}}/?Action=&Version=#Action=CreateUser"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=CreateUser");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=CreateUser"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=CreateUser")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=CreateUser"))
    .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}}/?Action=&Version=#Action=CreateUser")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=CreateUser")
  .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}}/?Action=&Version=#Action=CreateUser');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateUser',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=CreateUser';
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}}/?Action=&Version=#Action=CreateUser',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=CreateUser")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=CreateUser',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=CreateUser');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateUser',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=CreateUser';
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}}/?Action=&Version=#Action=CreateUser"]
                                                       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}}/?Action=&Version=#Action=CreateUser" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=CreateUser",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/?Action=&Version=#Action=CreateUser');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateUser');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateUser');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateUser' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateUser' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/?Action=&Version=", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=CreateUser"

querystring = {"Action":"","Version":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateUser"

queryString <- list(
  Action = "",
  Version = ""
)

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=CreateUser")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=CreateUser";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=CreateUser'
http POST '{{baseUrl}}/?Action=&Version=#Action=CreateUser'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=CreateUser'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=CreateUser")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "User": {
    "Arn": "arn:aws:iam::123456789012:user/Bob",
    "CreateDate": "2013-06-08T03:20:41.270Z",
    "Path": "/",
    "UserId": "AKIAIOSFODNN7EXAMPLE",
    "UserName": "Bob"
  }
}
POST POST_CreateVirtualMFADevice
{{baseUrl}}/#Action=CreateVirtualMFADevice
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=CreateVirtualMFADevice");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=CreateVirtualMFADevice" {:query-params {:Action ""
                                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=CreateVirtualMFADevice"

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}}/?Action=&Version=#Action=CreateVirtualMFADevice"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=CreateVirtualMFADevice");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=CreateVirtualMFADevice"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=CreateVirtualMFADevice")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=CreateVirtualMFADevice"))
    .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}}/?Action=&Version=#Action=CreateVirtualMFADevice")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=CreateVirtualMFADevice")
  .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}}/?Action=&Version=#Action=CreateVirtualMFADevice');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateVirtualMFADevice',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=CreateVirtualMFADevice';
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}}/?Action=&Version=#Action=CreateVirtualMFADevice',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=CreateVirtualMFADevice")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=CreateVirtualMFADevice',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=CreateVirtualMFADevice');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateVirtualMFADevice',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=CreateVirtualMFADevice';
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}}/?Action=&Version=#Action=CreateVirtualMFADevice"]
                                                       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}}/?Action=&Version=#Action=CreateVirtualMFADevice" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=CreateVirtualMFADevice",
  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}}/?Action=&Version=#Action=CreateVirtualMFADevice');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateVirtualMFADevice');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateVirtualMFADevice');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateVirtualMFADevice' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateVirtualMFADevice' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=CreateVirtualMFADevice"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateVirtualMFADevice"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=CreateVirtualMFADevice")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=CreateVirtualMFADevice";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=CreateVirtualMFADevice'
http POST '{{baseUrl}}/?Action=&Version=#Action=CreateVirtualMFADevice'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=CreateVirtualMFADevice'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=CreateVirtualMFADevice")! 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 POST_DeactivateMFADevice
{{baseUrl}}/#Action=DeactivateMFADevice
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=DeactivateMFADevice");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeactivateMFADevice" {:query-params {:Action ""
                                                                                       :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeactivateMFADevice"

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}}/?Action=&Version=#Action=DeactivateMFADevice"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=DeactivateMFADevice");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=DeactivateMFADevice"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=DeactivateMFADevice")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeactivateMFADevice"))
    .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}}/?Action=&Version=#Action=DeactivateMFADevice")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeactivateMFADevice")
  .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}}/?Action=&Version=#Action=DeactivateMFADevice');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeactivateMFADevice',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeactivateMFADevice';
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}}/?Action=&Version=#Action=DeactivateMFADevice',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeactivateMFADevice")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=DeactivateMFADevice',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=DeactivateMFADevice');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeactivateMFADevice',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=DeactivateMFADevice';
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}}/?Action=&Version=#Action=DeactivateMFADevice"]
                                                       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}}/?Action=&Version=#Action=DeactivateMFADevice" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeactivateMFADevice",
  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}}/?Action=&Version=#Action=DeactivateMFADevice');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeactivateMFADevice');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeactivateMFADevice');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=DeactivateMFADevice' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeactivateMFADevice' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeactivateMFADevice"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeactivateMFADevice"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=DeactivateMFADevice")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeactivateMFADevice";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=DeactivateMFADevice'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeactivateMFADevice'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeactivateMFADevice'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeactivateMFADevice")! 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 POST_DeleteAccessKey
{{baseUrl}}/#Action=DeleteAccessKey
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=DeleteAccessKey");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteAccessKey" {:query-params {:Action ""
                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteAccessKey"

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}}/?Action=&Version=#Action=DeleteAccessKey"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=DeleteAccessKey");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=DeleteAccessKey"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=DeleteAccessKey")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteAccessKey"))
    .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}}/?Action=&Version=#Action=DeleteAccessKey")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteAccessKey")
  .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}}/?Action=&Version=#Action=DeleteAccessKey');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteAccessKey',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteAccessKey';
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}}/?Action=&Version=#Action=DeleteAccessKey',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteAccessKey")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=DeleteAccessKey',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=DeleteAccessKey');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteAccessKey',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteAccessKey';
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}}/?Action=&Version=#Action=DeleteAccessKey"]
                                                       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}}/?Action=&Version=#Action=DeleteAccessKey" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteAccessKey",
  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}}/?Action=&Version=#Action=DeleteAccessKey');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteAccessKey');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteAccessKey');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteAccessKey' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteAccessKey' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteAccessKey"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteAccessKey"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=DeleteAccessKey")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteAccessKey";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=DeleteAccessKey'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteAccessKey'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteAccessKey'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteAccessKey")! 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 POST_DeleteAccountAlias
{{baseUrl}}/#Action=DeleteAccountAlias
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=DeleteAccountAlias");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteAccountAlias" {:query-params {:Action ""
                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteAccountAlias"

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}}/?Action=&Version=#Action=DeleteAccountAlias"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=DeleteAccountAlias");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=DeleteAccountAlias"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=DeleteAccountAlias")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteAccountAlias"))
    .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}}/?Action=&Version=#Action=DeleteAccountAlias")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteAccountAlias")
  .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}}/?Action=&Version=#Action=DeleteAccountAlias');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteAccountAlias',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteAccountAlias';
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}}/?Action=&Version=#Action=DeleteAccountAlias',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteAccountAlias")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=DeleteAccountAlias',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=DeleteAccountAlias');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteAccountAlias',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteAccountAlias';
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}}/?Action=&Version=#Action=DeleteAccountAlias"]
                                                       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}}/?Action=&Version=#Action=DeleteAccountAlias" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteAccountAlias",
  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}}/?Action=&Version=#Action=DeleteAccountAlias');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteAccountAlias');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteAccountAlias');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteAccountAlias' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteAccountAlias' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteAccountAlias"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteAccountAlias"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=DeleteAccountAlias")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteAccountAlias";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=DeleteAccountAlias'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteAccountAlias'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteAccountAlias'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteAccountAlias")! 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 POST_DeleteAccountPasswordPolicy
{{baseUrl}}/#Action=DeleteAccountPasswordPolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteAccountPasswordPolicy" {:query-params {:Action ""
                                                                                               :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy"

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}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy"))
    .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}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy")
  .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}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteAccountPasswordPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy';
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}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=DeleteAccountPasswordPolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=DeleteAccountPasswordPolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteAccountPasswordPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy';
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}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy"]
                                                       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}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy",
  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}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteAccountPasswordPolicy');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteAccountPasswordPolicy');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteAccountPasswordPolicy"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteAccountPasswordPolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteAccountPasswordPolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteAccountPasswordPolicy")! 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 POST_DeleteGroup
{{baseUrl}}/#Action=DeleteGroup
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=DeleteGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteGroup" {:query-params {:Action ""
                                                                               :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteGroup"

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}}/?Action=&Version=#Action=DeleteGroup"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=DeleteGroup");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=DeleteGroup"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=DeleteGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteGroup"))
    .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}}/?Action=&Version=#Action=DeleteGroup")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteGroup")
  .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}}/?Action=&Version=#Action=DeleteGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteGroup',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteGroup';
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}}/?Action=&Version=#Action=DeleteGroup',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteGroup")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=DeleteGroup',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=DeleteGroup');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteGroup',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteGroup';
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}}/?Action=&Version=#Action=DeleteGroup"]
                                                       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}}/?Action=&Version=#Action=DeleteGroup" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteGroup",
  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}}/?Action=&Version=#Action=DeleteGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteGroup');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteGroup');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteGroup' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteGroup' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteGroup"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteGroup"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=DeleteGroup")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteGroup";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=DeleteGroup'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteGroup'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteGroup")! 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 POST_DeleteGroupPolicy
{{baseUrl}}/#Action=DeleteGroupPolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=DeleteGroupPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteGroupPolicy" {:query-params {:Action ""
                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteGroupPolicy"

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}}/?Action=&Version=#Action=DeleteGroupPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=DeleteGroupPolicy");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=DeleteGroupPolicy"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=DeleteGroupPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteGroupPolicy"))
    .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}}/?Action=&Version=#Action=DeleteGroupPolicy")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteGroupPolicy")
  .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}}/?Action=&Version=#Action=DeleteGroupPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteGroupPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteGroupPolicy';
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}}/?Action=&Version=#Action=DeleteGroupPolicy',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteGroupPolicy")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=DeleteGroupPolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=DeleteGroupPolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteGroupPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteGroupPolicy';
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}}/?Action=&Version=#Action=DeleteGroupPolicy"]
                                                       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}}/?Action=&Version=#Action=DeleteGroupPolicy" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteGroupPolicy",
  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}}/?Action=&Version=#Action=DeleteGroupPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteGroupPolicy');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteGroupPolicy');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteGroupPolicy' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteGroupPolicy' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteGroupPolicy"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteGroupPolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=DeleteGroupPolicy")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteGroupPolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=DeleteGroupPolicy'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteGroupPolicy'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteGroupPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteGroupPolicy")! 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 POST_DeleteInstanceProfile
{{baseUrl}}/#Action=DeleteInstanceProfile
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=DeleteInstanceProfile");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteInstanceProfile" {:query-params {:Action ""
                                                                                         :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteInstanceProfile"

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}}/?Action=&Version=#Action=DeleteInstanceProfile"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=DeleteInstanceProfile");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=DeleteInstanceProfile"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=DeleteInstanceProfile")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteInstanceProfile"))
    .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}}/?Action=&Version=#Action=DeleteInstanceProfile")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteInstanceProfile")
  .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}}/?Action=&Version=#Action=DeleteInstanceProfile');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteInstanceProfile',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteInstanceProfile';
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}}/?Action=&Version=#Action=DeleteInstanceProfile',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteInstanceProfile")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=DeleteInstanceProfile',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=DeleteInstanceProfile');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteInstanceProfile',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteInstanceProfile';
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}}/?Action=&Version=#Action=DeleteInstanceProfile"]
                                                       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}}/?Action=&Version=#Action=DeleteInstanceProfile" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteInstanceProfile",
  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}}/?Action=&Version=#Action=DeleteInstanceProfile');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteInstanceProfile');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteInstanceProfile');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteInstanceProfile' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteInstanceProfile' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteInstanceProfile"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteInstanceProfile"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=DeleteInstanceProfile")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteInstanceProfile";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=DeleteInstanceProfile'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteInstanceProfile'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteInstanceProfile'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteInstanceProfile")! 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 POST_DeleteLoginProfile
{{baseUrl}}/#Action=DeleteLoginProfile
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=DeleteLoginProfile");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteLoginProfile" {:query-params {:Action ""
                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteLoginProfile"

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}}/?Action=&Version=#Action=DeleteLoginProfile"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=DeleteLoginProfile");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=DeleteLoginProfile"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=DeleteLoginProfile")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteLoginProfile"))
    .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}}/?Action=&Version=#Action=DeleteLoginProfile")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteLoginProfile")
  .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}}/?Action=&Version=#Action=DeleteLoginProfile');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteLoginProfile',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteLoginProfile';
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}}/?Action=&Version=#Action=DeleteLoginProfile',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteLoginProfile")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=DeleteLoginProfile',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=DeleteLoginProfile');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteLoginProfile',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteLoginProfile';
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}}/?Action=&Version=#Action=DeleteLoginProfile"]
                                                       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}}/?Action=&Version=#Action=DeleteLoginProfile" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteLoginProfile",
  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}}/?Action=&Version=#Action=DeleteLoginProfile');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteLoginProfile');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteLoginProfile');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteLoginProfile' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteLoginProfile' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteLoginProfile"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteLoginProfile"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=DeleteLoginProfile")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteLoginProfile";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=DeleteLoginProfile'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteLoginProfile'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteLoginProfile'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteLoginProfile")! 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 POST_DeleteOpenIDConnectProvider
{{baseUrl}}/#Action=DeleteOpenIDConnectProvider
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=DeleteOpenIDConnectProvider");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteOpenIDConnectProvider" {:query-params {:Action ""
                                                                                               :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteOpenIDConnectProvider"

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}}/?Action=&Version=#Action=DeleteOpenIDConnectProvider"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=DeleteOpenIDConnectProvider");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=DeleteOpenIDConnectProvider"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=DeleteOpenIDConnectProvider")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteOpenIDConnectProvider"))
    .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}}/?Action=&Version=#Action=DeleteOpenIDConnectProvider")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteOpenIDConnectProvider")
  .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}}/?Action=&Version=#Action=DeleteOpenIDConnectProvider');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteOpenIDConnectProvider',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteOpenIDConnectProvider';
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}}/?Action=&Version=#Action=DeleteOpenIDConnectProvider',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteOpenIDConnectProvider")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=DeleteOpenIDConnectProvider',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=DeleteOpenIDConnectProvider');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteOpenIDConnectProvider',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteOpenIDConnectProvider';
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}}/?Action=&Version=#Action=DeleteOpenIDConnectProvider"]
                                                       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}}/?Action=&Version=#Action=DeleteOpenIDConnectProvider" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteOpenIDConnectProvider",
  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}}/?Action=&Version=#Action=DeleteOpenIDConnectProvider');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteOpenIDConnectProvider');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteOpenIDConnectProvider');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteOpenIDConnectProvider' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteOpenIDConnectProvider' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteOpenIDConnectProvider"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteOpenIDConnectProvider"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=DeleteOpenIDConnectProvider")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteOpenIDConnectProvider";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=DeleteOpenIDConnectProvider'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteOpenIDConnectProvider'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteOpenIDConnectProvider'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteOpenIDConnectProvider")! 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 POST_DeletePolicy
{{baseUrl}}/#Action=DeletePolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=DeletePolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeletePolicy" {:query-params {:Action ""
                                                                                :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeletePolicy"

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}}/?Action=&Version=#Action=DeletePolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=DeletePolicy");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=DeletePolicy"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=DeletePolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeletePolicy"))
    .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}}/?Action=&Version=#Action=DeletePolicy")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeletePolicy")
  .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}}/?Action=&Version=#Action=DeletePolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeletePolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeletePolicy';
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}}/?Action=&Version=#Action=DeletePolicy',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeletePolicy")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=DeletePolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=DeletePolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeletePolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=DeletePolicy';
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}}/?Action=&Version=#Action=DeletePolicy"]
                                                       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}}/?Action=&Version=#Action=DeletePolicy" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeletePolicy",
  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}}/?Action=&Version=#Action=DeletePolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeletePolicy');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeletePolicy');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=DeletePolicy' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeletePolicy' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeletePolicy"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeletePolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=DeletePolicy")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeletePolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=DeletePolicy'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeletePolicy'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeletePolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeletePolicy")! 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 POST_DeletePolicyVersion
{{baseUrl}}/#Action=DeletePolicyVersion
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=DeletePolicyVersion");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeletePolicyVersion" {:query-params {:Action ""
                                                                                       :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeletePolicyVersion"

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}}/?Action=&Version=#Action=DeletePolicyVersion"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=DeletePolicyVersion");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=DeletePolicyVersion"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=DeletePolicyVersion")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeletePolicyVersion"))
    .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}}/?Action=&Version=#Action=DeletePolicyVersion")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeletePolicyVersion")
  .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}}/?Action=&Version=#Action=DeletePolicyVersion');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeletePolicyVersion',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeletePolicyVersion';
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}}/?Action=&Version=#Action=DeletePolicyVersion',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeletePolicyVersion")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=DeletePolicyVersion',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=DeletePolicyVersion');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeletePolicyVersion',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=DeletePolicyVersion';
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}}/?Action=&Version=#Action=DeletePolicyVersion"]
                                                       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}}/?Action=&Version=#Action=DeletePolicyVersion" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeletePolicyVersion",
  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}}/?Action=&Version=#Action=DeletePolicyVersion');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeletePolicyVersion');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeletePolicyVersion');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=DeletePolicyVersion' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeletePolicyVersion' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeletePolicyVersion"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeletePolicyVersion"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=DeletePolicyVersion")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeletePolicyVersion";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=DeletePolicyVersion'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeletePolicyVersion'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeletePolicyVersion'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeletePolicyVersion")! 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 POST_DeleteRole
{{baseUrl}}/#Action=DeleteRole
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=DeleteRole");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteRole" {:query-params {:Action ""
                                                                              :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteRole"

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}}/?Action=&Version=#Action=DeleteRole"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=DeleteRole");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=DeleteRole"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=DeleteRole")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteRole"))
    .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}}/?Action=&Version=#Action=DeleteRole")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteRole")
  .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}}/?Action=&Version=#Action=DeleteRole');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteRole',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteRole';
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}}/?Action=&Version=#Action=DeleteRole',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteRole")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=DeleteRole',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=DeleteRole');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteRole',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteRole';
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}}/?Action=&Version=#Action=DeleteRole"]
                                                       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}}/?Action=&Version=#Action=DeleteRole" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteRole",
  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}}/?Action=&Version=#Action=DeleteRole');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteRole');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteRole');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteRole' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteRole' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteRole"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteRole"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=DeleteRole")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteRole";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=DeleteRole'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteRole'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteRole'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteRole")! 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 POST_DeleteRolePermissionsBoundary
{{baseUrl}}/#Action=DeleteRolePermissionsBoundary
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=DeleteRolePermissionsBoundary");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteRolePermissionsBoundary" {:query-params {:Action ""
                                                                                                 :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteRolePermissionsBoundary"

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}}/?Action=&Version=#Action=DeleteRolePermissionsBoundary"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=DeleteRolePermissionsBoundary");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=DeleteRolePermissionsBoundary"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=DeleteRolePermissionsBoundary")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteRolePermissionsBoundary"))
    .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}}/?Action=&Version=#Action=DeleteRolePermissionsBoundary")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteRolePermissionsBoundary")
  .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}}/?Action=&Version=#Action=DeleteRolePermissionsBoundary');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteRolePermissionsBoundary',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteRolePermissionsBoundary';
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}}/?Action=&Version=#Action=DeleteRolePermissionsBoundary',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteRolePermissionsBoundary")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=DeleteRolePermissionsBoundary',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=DeleteRolePermissionsBoundary');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteRolePermissionsBoundary',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteRolePermissionsBoundary';
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}}/?Action=&Version=#Action=DeleteRolePermissionsBoundary"]
                                                       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}}/?Action=&Version=#Action=DeleteRolePermissionsBoundary" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteRolePermissionsBoundary",
  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}}/?Action=&Version=#Action=DeleteRolePermissionsBoundary');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteRolePermissionsBoundary');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteRolePermissionsBoundary');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteRolePermissionsBoundary' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteRolePermissionsBoundary' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteRolePermissionsBoundary"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteRolePermissionsBoundary"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=DeleteRolePermissionsBoundary")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteRolePermissionsBoundary";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=DeleteRolePermissionsBoundary'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteRolePermissionsBoundary'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteRolePermissionsBoundary'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteRolePermissionsBoundary")! 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 POST_DeleteRolePolicy
{{baseUrl}}/#Action=DeleteRolePolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=DeleteRolePolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteRolePolicy" {:query-params {:Action ""
                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteRolePolicy"

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}}/?Action=&Version=#Action=DeleteRolePolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=DeleteRolePolicy");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=DeleteRolePolicy"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=DeleteRolePolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteRolePolicy"))
    .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}}/?Action=&Version=#Action=DeleteRolePolicy")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteRolePolicy")
  .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}}/?Action=&Version=#Action=DeleteRolePolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteRolePolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteRolePolicy';
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}}/?Action=&Version=#Action=DeleteRolePolicy',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteRolePolicy")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=DeleteRolePolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=DeleteRolePolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteRolePolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteRolePolicy';
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}}/?Action=&Version=#Action=DeleteRolePolicy"]
                                                       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}}/?Action=&Version=#Action=DeleteRolePolicy" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteRolePolicy",
  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}}/?Action=&Version=#Action=DeleteRolePolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteRolePolicy');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteRolePolicy');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteRolePolicy' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteRolePolicy' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteRolePolicy"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteRolePolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=DeleteRolePolicy")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteRolePolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=DeleteRolePolicy'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteRolePolicy'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteRolePolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteRolePolicy")! 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 POST_DeleteSAMLProvider
{{baseUrl}}/#Action=DeleteSAMLProvider
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=DeleteSAMLProvider");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteSAMLProvider" {:query-params {:Action ""
                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteSAMLProvider"

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}}/?Action=&Version=#Action=DeleteSAMLProvider"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=DeleteSAMLProvider");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=DeleteSAMLProvider"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=DeleteSAMLProvider")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteSAMLProvider"))
    .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}}/?Action=&Version=#Action=DeleteSAMLProvider")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteSAMLProvider")
  .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}}/?Action=&Version=#Action=DeleteSAMLProvider');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteSAMLProvider',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteSAMLProvider';
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}}/?Action=&Version=#Action=DeleteSAMLProvider',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteSAMLProvider")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=DeleteSAMLProvider',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=DeleteSAMLProvider');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteSAMLProvider',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteSAMLProvider';
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}}/?Action=&Version=#Action=DeleteSAMLProvider"]
                                                       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}}/?Action=&Version=#Action=DeleteSAMLProvider" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteSAMLProvider",
  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}}/?Action=&Version=#Action=DeleteSAMLProvider');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteSAMLProvider');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteSAMLProvider');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteSAMLProvider' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteSAMLProvider' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteSAMLProvider"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteSAMLProvider"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=DeleteSAMLProvider")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteSAMLProvider";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=DeleteSAMLProvider'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteSAMLProvider'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteSAMLProvider'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteSAMLProvider")! 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 POST_DeleteSSHPublicKey
{{baseUrl}}/#Action=DeleteSSHPublicKey
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=DeleteSSHPublicKey");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteSSHPublicKey" {:query-params {:Action ""
                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteSSHPublicKey"

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}}/?Action=&Version=#Action=DeleteSSHPublicKey"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=DeleteSSHPublicKey");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=DeleteSSHPublicKey"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=DeleteSSHPublicKey")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteSSHPublicKey"))
    .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}}/?Action=&Version=#Action=DeleteSSHPublicKey")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteSSHPublicKey")
  .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}}/?Action=&Version=#Action=DeleteSSHPublicKey');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteSSHPublicKey',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteSSHPublicKey';
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}}/?Action=&Version=#Action=DeleteSSHPublicKey',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteSSHPublicKey")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=DeleteSSHPublicKey',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=DeleteSSHPublicKey');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteSSHPublicKey',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteSSHPublicKey';
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}}/?Action=&Version=#Action=DeleteSSHPublicKey"]
                                                       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}}/?Action=&Version=#Action=DeleteSSHPublicKey" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteSSHPublicKey",
  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}}/?Action=&Version=#Action=DeleteSSHPublicKey');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteSSHPublicKey');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteSSHPublicKey');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteSSHPublicKey' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteSSHPublicKey' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteSSHPublicKey"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteSSHPublicKey"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=DeleteSSHPublicKey")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteSSHPublicKey";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=DeleteSSHPublicKey'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteSSHPublicKey'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteSSHPublicKey'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteSSHPublicKey")! 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 POST_DeleteServerCertificate
{{baseUrl}}/#Action=DeleteServerCertificate
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=DeleteServerCertificate");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteServerCertificate" {:query-params {:Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteServerCertificate"

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}}/?Action=&Version=#Action=DeleteServerCertificate"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=DeleteServerCertificate");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=DeleteServerCertificate"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=DeleteServerCertificate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteServerCertificate"))
    .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}}/?Action=&Version=#Action=DeleteServerCertificate")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteServerCertificate")
  .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}}/?Action=&Version=#Action=DeleteServerCertificate');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteServerCertificate',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteServerCertificate';
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}}/?Action=&Version=#Action=DeleteServerCertificate',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteServerCertificate")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=DeleteServerCertificate',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=DeleteServerCertificate');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteServerCertificate',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteServerCertificate';
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}}/?Action=&Version=#Action=DeleteServerCertificate"]
                                                       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}}/?Action=&Version=#Action=DeleteServerCertificate" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteServerCertificate",
  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}}/?Action=&Version=#Action=DeleteServerCertificate');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteServerCertificate');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteServerCertificate');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteServerCertificate' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteServerCertificate' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteServerCertificate"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteServerCertificate"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=DeleteServerCertificate")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteServerCertificate";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=DeleteServerCertificate'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteServerCertificate'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteServerCertificate'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteServerCertificate")! 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 POST_DeleteServiceLinkedRole
{{baseUrl}}/#Action=DeleteServiceLinkedRole
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=DeleteServiceLinkedRole");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteServiceLinkedRole" {:query-params {:Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteServiceLinkedRole"

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}}/?Action=&Version=#Action=DeleteServiceLinkedRole"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=DeleteServiceLinkedRole");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=DeleteServiceLinkedRole"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=DeleteServiceLinkedRole")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteServiceLinkedRole"))
    .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}}/?Action=&Version=#Action=DeleteServiceLinkedRole")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteServiceLinkedRole")
  .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}}/?Action=&Version=#Action=DeleteServiceLinkedRole');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteServiceLinkedRole',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteServiceLinkedRole';
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}}/?Action=&Version=#Action=DeleteServiceLinkedRole',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteServiceLinkedRole")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=DeleteServiceLinkedRole',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=DeleteServiceLinkedRole');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteServiceLinkedRole',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteServiceLinkedRole';
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}}/?Action=&Version=#Action=DeleteServiceLinkedRole"]
                                                       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}}/?Action=&Version=#Action=DeleteServiceLinkedRole" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteServiceLinkedRole",
  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}}/?Action=&Version=#Action=DeleteServiceLinkedRole');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteServiceLinkedRole');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteServiceLinkedRole');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteServiceLinkedRole' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteServiceLinkedRole' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteServiceLinkedRole"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteServiceLinkedRole"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=DeleteServiceLinkedRole")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteServiceLinkedRole";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=DeleteServiceLinkedRole'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteServiceLinkedRole'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteServiceLinkedRole'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteServiceLinkedRole")! 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 POST_DeleteServiceSpecificCredential
{{baseUrl}}/#Action=DeleteServiceSpecificCredential
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=DeleteServiceSpecificCredential");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteServiceSpecificCredential" {:query-params {:Action ""
                                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteServiceSpecificCredential"

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}}/?Action=&Version=#Action=DeleteServiceSpecificCredential"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=DeleteServiceSpecificCredential");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=DeleteServiceSpecificCredential"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=DeleteServiceSpecificCredential")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteServiceSpecificCredential"))
    .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}}/?Action=&Version=#Action=DeleteServiceSpecificCredential")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteServiceSpecificCredential")
  .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}}/?Action=&Version=#Action=DeleteServiceSpecificCredential');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteServiceSpecificCredential',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteServiceSpecificCredential';
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}}/?Action=&Version=#Action=DeleteServiceSpecificCredential',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteServiceSpecificCredential")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=DeleteServiceSpecificCredential',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=DeleteServiceSpecificCredential');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteServiceSpecificCredential',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteServiceSpecificCredential';
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}}/?Action=&Version=#Action=DeleteServiceSpecificCredential"]
                                                       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}}/?Action=&Version=#Action=DeleteServiceSpecificCredential" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteServiceSpecificCredential",
  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}}/?Action=&Version=#Action=DeleteServiceSpecificCredential');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteServiceSpecificCredential');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteServiceSpecificCredential');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteServiceSpecificCredential' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteServiceSpecificCredential' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteServiceSpecificCredential"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteServiceSpecificCredential"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=DeleteServiceSpecificCredential")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteServiceSpecificCredential";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=DeleteServiceSpecificCredential'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteServiceSpecificCredential'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteServiceSpecificCredential'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteServiceSpecificCredential")! 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 POST_DeleteSigningCertificate
{{baseUrl}}/#Action=DeleteSigningCertificate
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=DeleteSigningCertificate");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteSigningCertificate" {:query-params {:Action ""
                                                                                            :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteSigningCertificate"

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}}/?Action=&Version=#Action=DeleteSigningCertificate"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=DeleteSigningCertificate");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=DeleteSigningCertificate"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=DeleteSigningCertificate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteSigningCertificate"))
    .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}}/?Action=&Version=#Action=DeleteSigningCertificate")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteSigningCertificate")
  .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}}/?Action=&Version=#Action=DeleteSigningCertificate');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteSigningCertificate',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteSigningCertificate';
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}}/?Action=&Version=#Action=DeleteSigningCertificate',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteSigningCertificate")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=DeleteSigningCertificate',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=DeleteSigningCertificate');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteSigningCertificate',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteSigningCertificate';
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}}/?Action=&Version=#Action=DeleteSigningCertificate"]
                                                       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}}/?Action=&Version=#Action=DeleteSigningCertificate" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteSigningCertificate",
  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}}/?Action=&Version=#Action=DeleteSigningCertificate');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteSigningCertificate');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteSigningCertificate');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteSigningCertificate' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteSigningCertificate' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteSigningCertificate"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteSigningCertificate"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=DeleteSigningCertificate")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteSigningCertificate";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=DeleteSigningCertificate'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteSigningCertificate'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteSigningCertificate'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteSigningCertificate")! 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 POST_DeleteUser
{{baseUrl}}/#Action=DeleteUser
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=DeleteUser");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteUser" {:query-params {:Action ""
                                                                              :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteUser"

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}}/?Action=&Version=#Action=DeleteUser"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=DeleteUser");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=DeleteUser"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=DeleteUser")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteUser"))
    .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}}/?Action=&Version=#Action=DeleteUser")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteUser")
  .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}}/?Action=&Version=#Action=DeleteUser');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteUser',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteUser';
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}}/?Action=&Version=#Action=DeleteUser',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteUser")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=DeleteUser',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=DeleteUser');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteUser',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteUser';
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}}/?Action=&Version=#Action=DeleteUser"]
                                                       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}}/?Action=&Version=#Action=DeleteUser" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteUser",
  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}}/?Action=&Version=#Action=DeleteUser');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteUser');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteUser');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteUser' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteUser' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteUser"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteUser"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=DeleteUser")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteUser";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=DeleteUser'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteUser'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteUser'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteUser")! 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 POST_DeleteUserPermissionsBoundary
{{baseUrl}}/#Action=DeleteUserPermissionsBoundary
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=DeleteUserPermissionsBoundary");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteUserPermissionsBoundary" {:query-params {:Action ""
                                                                                                 :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteUserPermissionsBoundary"

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}}/?Action=&Version=#Action=DeleteUserPermissionsBoundary"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=DeleteUserPermissionsBoundary");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=DeleteUserPermissionsBoundary"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=DeleteUserPermissionsBoundary")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteUserPermissionsBoundary"))
    .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}}/?Action=&Version=#Action=DeleteUserPermissionsBoundary")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteUserPermissionsBoundary")
  .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}}/?Action=&Version=#Action=DeleteUserPermissionsBoundary');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteUserPermissionsBoundary',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteUserPermissionsBoundary';
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}}/?Action=&Version=#Action=DeleteUserPermissionsBoundary',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteUserPermissionsBoundary")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=DeleteUserPermissionsBoundary',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=DeleteUserPermissionsBoundary');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteUserPermissionsBoundary',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteUserPermissionsBoundary';
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}}/?Action=&Version=#Action=DeleteUserPermissionsBoundary"]
                                                       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}}/?Action=&Version=#Action=DeleteUserPermissionsBoundary" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteUserPermissionsBoundary",
  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}}/?Action=&Version=#Action=DeleteUserPermissionsBoundary');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteUserPermissionsBoundary');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteUserPermissionsBoundary');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteUserPermissionsBoundary' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteUserPermissionsBoundary' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteUserPermissionsBoundary"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteUserPermissionsBoundary"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=DeleteUserPermissionsBoundary")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteUserPermissionsBoundary";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=DeleteUserPermissionsBoundary'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteUserPermissionsBoundary'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteUserPermissionsBoundary'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteUserPermissionsBoundary")! 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 POST_DeleteUserPolicy
{{baseUrl}}/#Action=DeleteUserPolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=DeleteUserPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteUserPolicy" {:query-params {:Action ""
                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteUserPolicy"

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}}/?Action=&Version=#Action=DeleteUserPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=DeleteUserPolicy");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=DeleteUserPolicy"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=DeleteUserPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteUserPolicy"))
    .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}}/?Action=&Version=#Action=DeleteUserPolicy")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteUserPolicy")
  .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}}/?Action=&Version=#Action=DeleteUserPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteUserPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteUserPolicy';
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}}/?Action=&Version=#Action=DeleteUserPolicy',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteUserPolicy")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=DeleteUserPolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=DeleteUserPolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteUserPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteUserPolicy';
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}}/?Action=&Version=#Action=DeleteUserPolicy"]
                                                       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}}/?Action=&Version=#Action=DeleteUserPolicy" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteUserPolicy",
  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}}/?Action=&Version=#Action=DeleteUserPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteUserPolicy');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteUserPolicy');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteUserPolicy' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteUserPolicy' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteUserPolicy"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteUserPolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=DeleteUserPolicy")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteUserPolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=DeleteUserPolicy'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteUserPolicy'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteUserPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteUserPolicy")! 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 POST_DeleteVirtualMFADevice
{{baseUrl}}/#Action=DeleteVirtualMFADevice
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=DeleteVirtualMFADevice");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteVirtualMFADevice" {:query-params {:Action ""
                                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteVirtualMFADevice"

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}}/?Action=&Version=#Action=DeleteVirtualMFADevice"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=DeleteVirtualMFADevice");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=DeleteVirtualMFADevice"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=DeleteVirtualMFADevice")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteVirtualMFADevice"))
    .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}}/?Action=&Version=#Action=DeleteVirtualMFADevice")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteVirtualMFADevice")
  .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}}/?Action=&Version=#Action=DeleteVirtualMFADevice');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteVirtualMFADevice',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteVirtualMFADevice';
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}}/?Action=&Version=#Action=DeleteVirtualMFADevice',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteVirtualMFADevice")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=DeleteVirtualMFADevice',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=DeleteVirtualMFADevice');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteVirtualMFADevice',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteVirtualMFADevice';
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}}/?Action=&Version=#Action=DeleteVirtualMFADevice"]
                                                       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}}/?Action=&Version=#Action=DeleteVirtualMFADevice" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteVirtualMFADevice",
  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}}/?Action=&Version=#Action=DeleteVirtualMFADevice');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteVirtualMFADevice');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteVirtualMFADevice');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteVirtualMFADevice' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteVirtualMFADevice' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DeleteVirtualMFADevice"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteVirtualMFADevice"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=DeleteVirtualMFADevice")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DeleteVirtualMFADevice";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=DeleteVirtualMFADevice'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteVirtualMFADevice'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteVirtualMFADevice'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteVirtualMFADevice")! 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 POST_DetachGroupPolicy
{{baseUrl}}/#Action=DetachGroupPolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=DetachGroupPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DetachGroupPolicy" {:query-params {:Action ""
                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DetachGroupPolicy"

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}}/?Action=&Version=#Action=DetachGroupPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=DetachGroupPolicy");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=DetachGroupPolicy"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=DetachGroupPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DetachGroupPolicy"))
    .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}}/?Action=&Version=#Action=DetachGroupPolicy")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DetachGroupPolicy")
  .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}}/?Action=&Version=#Action=DetachGroupPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DetachGroupPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DetachGroupPolicy';
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}}/?Action=&Version=#Action=DetachGroupPolicy',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DetachGroupPolicy")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=DetachGroupPolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=DetachGroupPolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DetachGroupPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=DetachGroupPolicy';
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}}/?Action=&Version=#Action=DetachGroupPolicy"]
                                                       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}}/?Action=&Version=#Action=DetachGroupPolicy" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DetachGroupPolicy",
  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}}/?Action=&Version=#Action=DetachGroupPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DetachGroupPolicy');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DetachGroupPolicy');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=DetachGroupPolicy' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DetachGroupPolicy' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DetachGroupPolicy"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DetachGroupPolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=DetachGroupPolicy")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DetachGroupPolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=DetachGroupPolicy'
http POST '{{baseUrl}}/?Action=&Version=#Action=DetachGroupPolicy'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DetachGroupPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DetachGroupPolicy")! 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 POST_DetachRolePolicy
{{baseUrl}}/#Action=DetachRolePolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=DetachRolePolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DetachRolePolicy" {:query-params {:Action ""
                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DetachRolePolicy"

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}}/?Action=&Version=#Action=DetachRolePolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=DetachRolePolicy");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=DetachRolePolicy"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=DetachRolePolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DetachRolePolicy"))
    .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}}/?Action=&Version=#Action=DetachRolePolicy")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DetachRolePolicy")
  .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}}/?Action=&Version=#Action=DetachRolePolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DetachRolePolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DetachRolePolicy';
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}}/?Action=&Version=#Action=DetachRolePolicy',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DetachRolePolicy")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=DetachRolePolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=DetachRolePolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DetachRolePolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=DetachRolePolicy';
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}}/?Action=&Version=#Action=DetachRolePolicy"]
                                                       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}}/?Action=&Version=#Action=DetachRolePolicy" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DetachRolePolicy",
  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}}/?Action=&Version=#Action=DetachRolePolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DetachRolePolicy');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DetachRolePolicy');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=DetachRolePolicy' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DetachRolePolicy' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DetachRolePolicy"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DetachRolePolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=DetachRolePolicy")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DetachRolePolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=DetachRolePolicy'
http POST '{{baseUrl}}/?Action=&Version=#Action=DetachRolePolicy'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DetachRolePolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DetachRolePolicy")! 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 POST_DetachUserPolicy
{{baseUrl}}/#Action=DetachUserPolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=DetachUserPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DetachUserPolicy" {:query-params {:Action ""
                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DetachUserPolicy"

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}}/?Action=&Version=#Action=DetachUserPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=DetachUserPolicy");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=DetachUserPolicy"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=DetachUserPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DetachUserPolicy"))
    .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}}/?Action=&Version=#Action=DetachUserPolicy")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DetachUserPolicy")
  .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}}/?Action=&Version=#Action=DetachUserPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DetachUserPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DetachUserPolicy';
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}}/?Action=&Version=#Action=DetachUserPolicy',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DetachUserPolicy")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=DetachUserPolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=DetachUserPolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DetachUserPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=DetachUserPolicy';
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}}/?Action=&Version=#Action=DetachUserPolicy"]
                                                       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}}/?Action=&Version=#Action=DetachUserPolicy" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DetachUserPolicy",
  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}}/?Action=&Version=#Action=DetachUserPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DetachUserPolicy');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DetachUserPolicy');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=DetachUserPolicy' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DetachUserPolicy' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DetachUserPolicy"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DetachUserPolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=DetachUserPolicy")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DetachUserPolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=DetachUserPolicy'
http POST '{{baseUrl}}/?Action=&Version=#Action=DetachUserPolicy'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DetachUserPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DetachUserPolicy")! 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 POST_EnableMFADevice
{{baseUrl}}/#Action=EnableMFADevice
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=EnableMFADevice");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=EnableMFADevice" {:query-params {:Action ""
                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=EnableMFADevice"

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}}/?Action=&Version=#Action=EnableMFADevice"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=EnableMFADevice");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=EnableMFADevice"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=EnableMFADevice")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=EnableMFADevice"))
    .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}}/?Action=&Version=#Action=EnableMFADevice")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=EnableMFADevice")
  .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}}/?Action=&Version=#Action=EnableMFADevice');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=EnableMFADevice',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=EnableMFADevice';
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}}/?Action=&Version=#Action=EnableMFADevice',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=EnableMFADevice")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=EnableMFADevice',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=EnableMFADevice');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=EnableMFADevice',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=EnableMFADevice';
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}}/?Action=&Version=#Action=EnableMFADevice"]
                                                       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}}/?Action=&Version=#Action=EnableMFADevice" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=EnableMFADevice",
  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}}/?Action=&Version=#Action=EnableMFADevice');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=EnableMFADevice');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=EnableMFADevice');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=EnableMFADevice' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=EnableMFADevice' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=EnableMFADevice"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=EnableMFADevice"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=EnableMFADevice")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=EnableMFADevice";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=EnableMFADevice'
http POST '{{baseUrl}}/?Action=&Version=#Action=EnableMFADevice'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=EnableMFADevice'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=EnableMFADevice")! 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 POST_GenerateCredentialReport
{{baseUrl}}/#Action=GenerateCredentialReport
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=GenerateCredentialReport" {:query-params {:Action ""
                                                                                            :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport"

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}}/?Action=&Version=#Action=GenerateCredentialReport"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport"))
    .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}}/?Action=&Version=#Action=GenerateCredentialReport")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport")
  .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}}/?Action=&Version=#Action=GenerateCredentialReport');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GenerateCredentialReport',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport';
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}}/?Action=&Version=#Action=GenerateCredentialReport',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=GenerateCredentialReport',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=GenerateCredentialReport');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GenerateCredentialReport',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport';
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}}/?Action=&Version=#Action=GenerateCredentialReport"]
                                                       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}}/?Action=&Version=#Action=GenerateCredentialReport" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport",
  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}}/?Action=&Version=#Action=GenerateCredentialReport');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GenerateCredentialReport');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GenerateCredentialReport');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GenerateCredentialReport"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GenerateCredentialReport"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GenerateCredentialReport";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=GenerateCredentialReport'
http POST '{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GenerateCredentialReport")! 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 POST_GenerateOrganizationsAccessReport
{{baseUrl}}/#Action=GenerateOrganizationsAccessReport
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GenerateOrganizationsAccessReport");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=GenerateOrganizationsAccessReport" {:query-params {:Action ""
                                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GenerateOrganizationsAccessReport"

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}}/?Action=&Version=#Action=GenerateOrganizationsAccessReport"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GenerateOrganizationsAccessReport");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GenerateOrganizationsAccessReport"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=GenerateOrganizationsAccessReport")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GenerateOrganizationsAccessReport"))
    .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}}/?Action=&Version=#Action=GenerateOrganizationsAccessReport")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=GenerateOrganizationsAccessReport")
  .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}}/?Action=&Version=#Action=GenerateOrganizationsAccessReport');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GenerateOrganizationsAccessReport',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GenerateOrganizationsAccessReport';
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}}/?Action=&Version=#Action=GenerateOrganizationsAccessReport',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GenerateOrganizationsAccessReport")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=GenerateOrganizationsAccessReport',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=GenerateOrganizationsAccessReport');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GenerateOrganizationsAccessReport',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GenerateOrganizationsAccessReport';
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}}/?Action=&Version=#Action=GenerateOrganizationsAccessReport"]
                                                       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}}/?Action=&Version=#Action=GenerateOrganizationsAccessReport" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GenerateOrganizationsAccessReport",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/?Action=&Version=#Action=GenerateOrganizationsAccessReport');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GenerateOrganizationsAccessReport');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GenerateOrganizationsAccessReport');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GenerateOrganizationsAccessReport' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GenerateOrganizationsAccessReport' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/?Action=&Version=", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GenerateOrganizationsAccessReport"

querystring = {"Action":"","Version":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GenerateOrganizationsAccessReport"

queryString <- list(
  Action = "",
  Version = ""
)

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GenerateOrganizationsAccessReport")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GenerateOrganizationsAccessReport";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=GenerateOrganizationsAccessReport'
http POST '{{baseUrl}}/?Action=&Version=#Action=GenerateOrganizationsAccessReport'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GenerateOrganizationsAccessReport'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GenerateOrganizationsAccessReport")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "JobId": "examplea-1234-b567-cde8-90fg123abcd4"
}
POST POST_GenerateServiceLastAccessedDetails
{{baseUrl}}/#Action=GenerateServiceLastAccessedDetails
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GenerateServiceLastAccessedDetails");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=GenerateServiceLastAccessedDetails" {:query-params {:Action ""
                                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GenerateServiceLastAccessedDetails"

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}}/?Action=&Version=#Action=GenerateServiceLastAccessedDetails"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GenerateServiceLastAccessedDetails");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GenerateServiceLastAccessedDetails"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=GenerateServiceLastAccessedDetails")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GenerateServiceLastAccessedDetails"))
    .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}}/?Action=&Version=#Action=GenerateServiceLastAccessedDetails")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=GenerateServiceLastAccessedDetails")
  .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}}/?Action=&Version=#Action=GenerateServiceLastAccessedDetails');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GenerateServiceLastAccessedDetails',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GenerateServiceLastAccessedDetails';
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}}/?Action=&Version=#Action=GenerateServiceLastAccessedDetails',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GenerateServiceLastAccessedDetails")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=GenerateServiceLastAccessedDetails',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=GenerateServiceLastAccessedDetails');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GenerateServiceLastAccessedDetails',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GenerateServiceLastAccessedDetails';
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}}/?Action=&Version=#Action=GenerateServiceLastAccessedDetails"]
                                                       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}}/?Action=&Version=#Action=GenerateServiceLastAccessedDetails" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GenerateServiceLastAccessedDetails",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/?Action=&Version=#Action=GenerateServiceLastAccessedDetails');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GenerateServiceLastAccessedDetails');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GenerateServiceLastAccessedDetails');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GenerateServiceLastAccessedDetails' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GenerateServiceLastAccessedDetails' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/?Action=&Version=", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GenerateServiceLastAccessedDetails"

querystring = {"Action":"","Version":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GenerateServiceLastAccessedDetails"

queryString <- list(
  Action = "",
  Version = ""
)

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GenerateServiceLastAccessedDetails")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GenerateServiceLastAccessedDetails";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=GenerateServiceLastAccessedDetails'
http POST '{{baseUrl}}/?Action=&Version=#Action=GenerateServiceLastAccessedDetails'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GenerateServiceLastAccessedDetails'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GenerateServiceLastAccessedDetails")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "JobId": "examplef-1305-c245-eba4-71fe298bcda7"
}
POST POST_GetAccessKeyLastUsed
{{baseUrl}}/#Action=GetAccessKeyLastUsed
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetAccessKeyLastUsed");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=GetAccessKeyLastUsed" {:query-params {:Action ""
                                                                                        :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetAccessKeyLastUsed"

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}}/?Action=&Version=#Action=GetAccessKeyLastUsed"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetAccessKeyLastUsed");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetAccessKeyLastUsed"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=GetAccessKeyLastUsed")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetAccessKeyLastUsed"))
    .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}}/?Action=&Version=#Action=GetAccessKeyLastUsed")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=GetAccessKeyLastUsed")
  .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}}/?Action=&Version=#Action=GetAccessKeyLastUsed');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetAccessKeyLastUsed',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetAccessKeyLastUsed';
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}}/?Action=&Version=#Action=GetAccessKeyLastUsed',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetAccessKeyLastUsed")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=GetAccessKeyLastUsed',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=GetAccessKeyLastUsed');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetAccessKeyLastUsed',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetAccessKeyLastUsed';
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}}/?Action=&Version=#Action=GetAccessKeyLastUsed"]
                                                       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}}/?Action=&Version=#Action=GetAccessKeyLastUsed" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetAccessKeyLastUsed",
  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}}/?Action=&Version=#Action=GetAccessKeyLastUsed');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetAccessKeyLastUsed');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetAccessKeyLastUsed');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetAccessKeyLastUsed' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetAccessKeyLastUsed' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetAccessKeyLastUsed"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetAccessKeyLastUsed"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetAccessKeyLastUsed")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetAccessKeyLastUsed";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=GetAccessKeyLastUsed'
http POST '{{baseUrl}}/?Action=&Version=#Action=GetAccessKeyLastUsed'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetAccessKeyLastUsed'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetAccessKeyLastUsed")! 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 POST_GetAccountAuthorizationDetails
{{baseUrl}}/#Action=GetAccountAuthorizationDetails
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=GetAccountAuthorizationDetails" {:query-params {:Action ""
                                                                                                  :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails"

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}}/?Action=&Version=#Action=GetAccountAuthorizationDetails"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails"))
    .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}}/?Action=&Version=#Action=GetAccountAuthorizationDetails")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails")
  .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}}/?Action=&Version=#Action=GetAccountAuthorizationDetails');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetAccountAuthorizationDetails',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails';
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}}/?Action=&Version=#Action=GetAccountAuthorizationDetails',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=GetAccountAuthorizationDetails',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=GetAccountAuthorizationDetails');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetAccountAuthorizationDetails',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails';
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}}/?Action=&Version=#Action=GetAccountAuthorizationDetails"]
                                                       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}}/?Action=&Version=#Action=GetAccountAuthorizationDetails" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails",
  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}}/?Action=&Version=#Action=GetAccountAuthorizationDetails');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetAccountAuthorizationDetails');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetAccountAuthorizationDetails');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetAccountAuthorizationDetails"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetAccountAuthorizationDetails"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetAccountAuthorizationDetails";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=GetAccountAuthorizationDetails'
http POST '{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetAccountAuthorizationDetails")! 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 POST_GetAccountPasswordPolicy
{{baseUrl}}/#Action=GetAccountPasswordPolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=GetAccountPasswordPolicy" {:query-params {:Action ""
                                                                                            :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy"

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}}/?Action=&Version=#Action=GetAccountPasswordPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy"))
    .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}}/?Action=&Version=#Action=GetAccountPasswordPolicy")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy")
  .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}}/?Action=&Version=#Action=GetAccountPasswordPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetAccountPasswordPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy';
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}}/?Action=&Version=#Action=GetAccountPasswordPolicy',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=GetAccountPasswordPolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=GetAccountPasswordPolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetAccountPasswordPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy';
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}}/?Action=&Version=#Action=GetAccountPasswordPolicy"]
                                                       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}}/?Action=&Version=#Action=GetAccountPasswordPolicy" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy",
  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}}/?Action=&Version=#Action=GetAccountPasswordPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetAccountPasswordPolicy');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetAccountPasswordPolicy');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetAccountPasswordPolicy"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetAccountPasswordPolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetAccountPasswordPolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=GetAccountPasswordPolicy'
http POST '{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetAccountPasswordPolicy")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "PasswordPolicy": {
    "AllowUsersToChangePassword": false,
    "ExpirePasswords": false,
    "HardExpiry": false,
    "MaxPasswordAge": 90,
    "MinimumPasswordLength": 8,
    "PasswordReusePrevention": 12,
    "RequireLowercaseCharacters": false,
    "RequireNumbers": true,
    "RequireSymbols": true,
    "RequireUppercaseCharacters": false
  }
}
POST POST_GetAccountSummary
{{baseUrl}}/#Action=GetAccountSummary
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=GetAccountSummary" {:query-params {:Action ""
                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary"

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}}/?Action=&Version=#Action=GetAccountSummary"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary"))
    .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}}/?Action=&Version=#Action=GetAccountSummary")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary")
  .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}}/?Action=&Version=#Action=GetAccountSummary');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetAccountSummary',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary';
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}}/?Action=&Version=#Action=GetAccountSummary',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=GetAccountSummary',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=GetAccountSummary');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetAccountSummary',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary';
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}}/?Action=&Version=#Action=GetAccountSummary"]
                                                       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}}/?Action=&Version=#Action=GetAccountSummary" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary",
  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}}/?Action=&Version=#Action=GetAccountSummary');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetAccountSummary');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetAccountSummary');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetAccountSummary"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetAccountSummary"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetAccountSummary";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=GetAccountSummary'
http POST '{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetAccountSummary")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "SummaryMap": {
    "AccessKeysPerUserQuota": 2,
    "AccountAccessKeysPresent": 1,
    "AccountMFAEnabled": 0,
    "AccountSigningCertificatesPresent": 0,
    "AttachedPoliciesPerGroupQuota": 10,
    "AttachedPoliciesPerRoleQuota": 10,
    "AttachedPoliciesPerUserQuota": 10,
    "GlobalEndpointTokenVersion": 2,
    "GroupPolicySizeQuota": 5120,
    "Groups": 15,
    "GroupsPerUserQuota": 10,
    "GroupsQuota": 100,
    "MFADevices": 6,
    "MFADevicesInUse": 3,
    "Policies": 8,
    "PoliciesQuota": 1000,
    "PolicySizeQuota": 5120,
    "PolicyVersionsInUse": 22,
    "PolicyVersionsInUseQuota": 10000,
    "ServerCertificates": 1,
    "ServerCertificatesQuota": 20,
    "SigningCertificatesPerUserQuota": 2,
    "UserPolicySizeQuota": 2048,
    "Users": 27,
    "UsersQuota": 5000,
    "VersionsPerPolicyQuota": 5
  }
}
POST POST_GetContextKeysForCustomPolicy
{{baseUrl}}/#Action=GetContextKeysForCustomPolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForCustomPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=GetContextKeysForCustomPolicy" {:query-params {:Action ""
                                                                                                 :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForCustomPolicy"

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}}/?Action=&Version=#Action=GetContextKeysForCustomPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForCustomPolicy");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForCustomPolicy"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForCustomPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForCustomPolicy"))
    .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}}/?Action=&Version=#Action=GetContextKeysForCustomPolicy")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForCustomPolicy")
  .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}}/?Action=&Version=#Action=GetContextKeysForCustomPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetContextKeysForCustomPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForCustomPolicy';
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}}/?Action=&Version=#Action=GetContextKeysForCustomPolicy',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForCustomPolicy")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=GetContextKeysForCustomPolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=GetContextKeysForCustomPolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetContextKeysForCustomPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForCustomPolicy';
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}}/?Action=&Version=#Action=GetContextKeysForCustomPolicy"]
                                                       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}}/?Action=&Version=#Action=GetContextKeysForCustomPolicy" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForCustomPolicy",
  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}}/?Action=&Version=#Action=GetContextKeysForCustomPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetContextKeysForCustomPolicy');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetContextKeysForCustomPolicy');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForCustomPolicy' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForCustomPolicy' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetContextKeysForCustomPolicy"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetContextKeysForCustomPolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForCustomPolicy")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetContextKeysForCustomPolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=GetContextKeysForCustomPolicy'
http POST '{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForCustomPolicy'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForCustomPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForCustomPolicy")! 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 POST_GetContextKeysForPrincipalPolicy
{{baseUrl}}/#Action=GetContextKeysForPrincipalPolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForPrincipalPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=GetContextKeysForPrincipalPolicy" {:query-params {:Action ""
                                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForPrincipalPolicy"

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}}/?Action=&Version=#Action=GetContextKeysForPrincipalPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForPrincipalPolicy");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForPrincipalPolicy"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForPrincipalPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForPrincipalPolicy"))
    .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}}/?Action=&Version=#Action=GetContextKeysForPrincipalPolicy")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForPrincipalPolicy")
  .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}}/?Action=&Version=#Action=GetContextKeysForPrincipalPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetContextKeysForPrincipalPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForPrincipalPolicy';
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}}/?Action=&Version=#Action=GetContextKeysForPrincipalPolicy',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForPrincipalPolicy")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=GetContextKeysForPrincipalPolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=GetContextKeysForPrincipalPolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetContextKeysForPrincipalPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForPrincipalPolicy';
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}}/?Action=&Version=#Action=GetContextKeysForPrincipalPolicy"]
                                                       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}}/?Action=&Version=#Action=GetContextKeysForPrincipalPolicy" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForPrincipalPolicy",
  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}}/?Action=&Version=#Action=GetContextKeysForPrincipalPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetContextKeysForPrincipalPolicy');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetContextKeysForPrincipalPolicy');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForPrincipalPolicy' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForPrincipalPolicy' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetContextKeysForPrincipalPolicy"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetContextKeysForPrincipalPolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForPrincipalPolicy")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetContextKeysForPrincipalPolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=GetContextKeysForPrincipalPolicy'
http POST '{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForPrincipalPolicy'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForPrincipalPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetContextKeysForPrincipalPolicy")! 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 POST_GetCredentialReport
{{baseUrl}}/#Action=GetCredentialReport
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=GetCredentialReport" {:query-params {:Action ""
                                                                                       :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport"

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}}/?Action=&Version=#Action=GetCredentialReport"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport"))
    .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}}/?Action=&Version=#Action=GetCredentialReport")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport")
  .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}}/?Action=&Version=#Action=GetCredentialReport');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetCredentialReport',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport';
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}}/?Action=&Version=#Action=GetCredentialReport',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=GetCredentialReport',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=GetCredentialReport');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetCredentialReport',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport';
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}}/?Action=&Version=#Action=GetCredentialReport"]
                                                       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}}/?Action=&Version=#Action=GetCredentialReport" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport",
  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}}/?Action=&Version=#Action=GetCredentialReport');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetCredentialReport');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetCredentialReport');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetCredentialReport"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetCredentialReport"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetCredentialReport";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=GetCredentialReport'
http POST '{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetCredentialReport")! 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 POST_GetGroup
{{baseUrl}}/#Action=GetGroup
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=GetGroup" {:query-params {:Action ""
                                                                            :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetGroup"

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}}/?Action=&Version=#Action=GetGroup"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetGroup");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetGroup"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=GetGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetGroup"))
    .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}}/?Action=&Version=#Action=GetGroup")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=GetGroup")
  .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}}/?Action=&Version=#Action=GetGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetGroup',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetGroup';
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}}/?Action=&Version=#Action=GetGroup',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetGroup")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=GetGroup',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=GetGroup');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetGroup',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetGroup';
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}}/?Action=&Version=#Action=GetGroup"]
                                                       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}}/?Action=&Version=#Action=GetGroup" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetGroup",
  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}}/?Action=&Version=#Action=GetGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetGroup');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetGroup');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetGroup' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetGroup' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetGroup"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetGroup"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetGroup")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetGroup";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=GetGroup'
http POST '{{baseUrl}}/?Action=&Version=#Action=GetGroup'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetGroup")! 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 POST_GetGroupPolicy
{{baseUrl}}/#Action=GetGroupPolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetGroupPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=GetGroupPolicy" {:query-params {:Action ""
                                                                                  :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetGroupPolicy"

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}}/?Action=&Version=#Action=GetGroupPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetGroupPolicy");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetGroupPolicy"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=GetGroupPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetGroupPolicy"))
    .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}}/?Action=&Version=#Action=GetGroupPolicy")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=GetGroupPolicy")
  .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}}/?Action=&Version=#Action=GetGroupPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetGroupPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetGroupPolicy';
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}}/?Action=&Version=#Action=GetGroupPolicy',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetGroupPolicy")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=GetGroupPolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=GetGroupPolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetGroupPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetGroupPolicy';
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}}/?Action=&Version=#Action=GetGroupPolicy"]
                                                       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}}/?Action=&Version=#Action=GetGroupPolicy" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetGroupPolicy",
  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}}/?Action=&Version=#Action=GetGroupPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetGroupPolicy');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetGroupPolicy');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetGroupPolicy' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetGroupPolicy' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetGroupPolicy"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetGroupPolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetGroupPolicy")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetGroupPolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=GetGroupPolicy'
http POST '{{baseUrl}}/?Action=&Version=#Action=GetGroupPolicy'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetGroupPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetGroupPolicy")! 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 POST_GetInstanceProfile
{{baseUrl}}/#Action=GetInstanceProfile
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetInstanceProfile");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=GetInstanceProfile" {:query-params {:Action ""
                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetInstanceProfile"

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}}/?Action=&Version=#Action=GetInstanceProfile"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetInstanceProfile");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetInstanceProfile"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=GetInstanceProfile")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetInstanceProfile"))
    .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}}/?Action=&Version=#Action=GetInstanceProfile")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=GetInstanceProfile")
  .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}}/?Action=&Version=#Action=GetInstanceProfile');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetInstanceProfile',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetInstanceProfile';
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}}/?Action=&Version=#Action=GetInstanceProfile',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetInstanceProfile")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=GetInstanceProfile',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=GetInstanceProfile');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetInstanceProfile',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetInstanceProfile';
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}}/?Action=&Version=#Action=GetInstanceProfile"]
                                                       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}}/?Action=&Version=#Action=GetInstanceProfile" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetInstanceProfile",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/?Action=&Version=#Action=GetInstanceProfile');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetInstanceProfile');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetInstanceProfile');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetInstanceProfile' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetInstanceProfile' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/?Action=&Version=", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetInstanceProfile"

querystring = {"Action":"","Version":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetInstanceProfile"

queryString <- list(
  Action = "",
  Version = ""
)

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetInstanceProfile")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetInstanceProfile";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=GetInstanceProfile'
http POST '{{baseUrl}}/?Action=&Version=#Action=GetInstanceProfile'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetInstanceProfile'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetInstanceProfile")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "InstanceProfile": {
    "Arn": "arn:aws:iam::336924118301:instance-profile/ExampleInstanceProfile",
    "CreateDate": "2013-06-12T23:52:02Z",
    "InstanceProfileId": "AID2MAB8DPLSRHEXAMPLE",
    "InstanceProfileName": "ExampleInstanceProfile",
    "Path": "/",
    "Roles": [
      {
        "Arn": "arn:aws:iam::336924118301:role/Test-Role",
        "AssumeRolePolicyDocument": "",
        "CreateDate": "2013-01-09T06:33:26Z",
        "Path": "/",
        "RoleId": "AIDGPMS9RO4H3FEXAMPLE",
        "RoleName": "Test-Role"
      }
    ]
  }
}
POST POST_GetLoginProfile
{{baseUrl}}/#Action=GetLoginProfile
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetLoginProfile");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=GetLoginProfile" {:query-params {:Action ""
                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetLoginProfile"

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}}/?Action=&Version=#Action=GetLoginProfile"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetLoginProfile");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetLoginProfile"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=GetLoginProfile")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetLoginProfile"))
    .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}}/?Action=&Version=#Action=GetLoginProfile")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=GetLoginProfile")
  .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}}/?Action=&Version=#Action=GetLoginProfile');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetLoginProfile',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetLoginProfile';
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}}/?Action=&Version=#Action=GetLoginProfile',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetLoginProfile")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=GetLoginProfile',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=GetLoginProfile');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetLoginProfile',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetLoginProfile';
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}}/?Action=&Version=#Action=GetLoginProfile"]
                                                       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}}/?Action=&Version=#Action=GetLoginProfile" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetLoginProfile",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/?Action=&Version=#Action=GetLoginProfile');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetLoginProfile');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetLoginProfile');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetLoginProfile' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetLoginProfile' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/?Action=&Version=", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetLoginProfile"

querystring = {"Action":"","Version":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetLoginProfile"

queryString <- list(
  Action = "",
  Version = ""
)

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetLoginProfile")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetLoginProfile";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=GetLoginProfile'
http POST '{{baseUrl}}/?Action=&Version=#Action=GetLoginProfile'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetLoginProfile'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetLoginProfile")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "LoginProfile": {
    "CreateDate": "2012-09-21T23:03:39Z",
    "UserName": "Anika"
  }
}
POST POST_GetOpenIDConnectProvider
{{baseUrl}}/#Action=GetOpenIDConnectProvider
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetOpenIDConnectProvider");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=GetOpenIDConnectProvider" {:query-params {:Action ""
                                                                                            :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetOpenIDConnectProvider"

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}}/?Action=&Version=#Action=GetOpenIDConnectProvider"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetOpenIDConnectProvider");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetOpenIDConnectProvider"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=GetOpenIDConnectProvider")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetOpenIDConnectProvider"))
    .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}}/?Action=&Version=#Action=GetOpenIDConnectProvider")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=GetOpenIDConnectProvider")
  .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}}/?Action=&Version=#Action=GetOpenIDConnectProvider');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetOpenIDConnectProvider',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetOpenIDConnectProvider';
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}}/?Action=&Version=#Action=GetOpenIDConnectProvider',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetOpenIDConnectProvider")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=GetOpenIDConnectProvider',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=GetOpenIDConnectProvider');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetOpenIDConnectProvider',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetOpenIDConnectProvider';
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}}/?Action=&Version=#Action=GetOpenIDConnectProvider"]
                                                       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}}/?Action=&Version=#Action=GetOpenIDConnectProvider" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetOpenIDConnectProvider",
  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}}/?Action=&Version=#Action=GetOpenIDConnectProvider');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetOpenIDConnectProvider');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetOpenIDConnectProvider');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetOpenIDConnectProvider' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetOpenIDConnectProvider' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetOpenIDConnectProvider"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetOpenIDConnectProvider"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetOpenIDConnectProvider")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetOpenIDConnectProvider";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=GetOpenIDConnectProvider'
http POST '{{baseUrl}}/?Action=&Version=#Action=GetOpenIDConnectProvider'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetOpenIDConnectProvider'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetOpenIDConnectProvider")! 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 POST_GetOrganizationsAccessReport
{{baseUrl}}/#Action=GetOrganizationsAccessReport
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetOrganizationsAccessReport");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=GetOrganizationsAccessReport" {:query-params {:Action ""
                                                                                                :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetOrganizationsAccessReport"

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}}/?Action=&Version=#Action=GetOrganizationsAccessReport"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetOrganizationsAccessReport");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetOrganizationsAccessReport"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=GetOrganizationsAccessReport")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetOrganizationsAccessReport"))
    .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}}/?Action=&Version=#Action=GetOrganizationsAccessReport")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=GetOrganizationsAccessReport")
  .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}}/?Action=&Version=#Action=GetOrganizationsAccessReport');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetOrganizationsAccessReport',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetOrganizationsAccessReport';
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}}/?Action=&Version=#Action=GetOrganizationsAccessReport',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetOrganizationsAccessReport")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=GetOrganizationsAccessReport',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=GetOrganizationsAccessReport');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetOrganizationsAccessReport',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetOrganizationsAccessReport';
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}}/?Action=&Version=#Action=GetOrganizationsAccessReport"]
                                                       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}}/?Action=&Version=#Action=GetOrganizationsAccessReport" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetOrganizationsAccessReport",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/?Action=&Version=#Action=GetOrganizationsAccessReport');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetOrganizationsAccessReport');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetOrganizationsAccessReport');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetOrganizationsAccessReport' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetOrganizationsAccessReport' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/?Action=&Version=", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetOrganizationsAccessReport"

querystring = {"Action":"","Version":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetOrganizationsAccessReport"

queryString <- list(
  Action = "",
  Version = ""
)

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetOrganizationsAccessReport")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetOrganizationsAccessReport";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=GetOrganizationsAccessReport'
http POST '{{baseUrl}}/?Action=&Version=#Action=GetOrganizationsAccessReport'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetOrganizationsAccessReport'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetOrganizationsAccessReport")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "AccessDetails": [
    {
      "EntityPath": "o-a1b2c3d4e5/r-f6g7h8i9j0example/ou-1a2b3c-k9l8m7n6o5example/111122223333",
      "LastAuthenticatedTime": "2019-05-25T16:29:52Z",
      "Region": "us-east-1",
      "ServiceName": "Amazon DynamoDB",
      "ServiceNamespace": "dynamodb",
      "TotalAuthenticatedEntities": 2
    },
    {
      "EntityPath": "o-a1b2c3d4e5/r-f6g7h8i9j0example/ou-1a2b3c-k9l8m7n6o5example/123456789012",
      "LastAuthenticatedTime": "2019-06-15T13:12:06Z",
      "Region": "us-east-1",
      "ServiceName": "AWS Identity and Access Management",
      "ServiceNamespace": "iam",
      "TotalAuthenticatedEntities": 4
    },
    {
      "ServiceName": "Amazon Simple Storage Service",
      "ServiceNamespace": "s3",
      "TotalAuthenticatedEntities": 0
    }
  ],
  "IsTruncated": false,
  "JobCompletionDate": "2019-06-18T19:47:35.241Z",
  "JobCreationDate": "2019-06-18T19:47:31.466Z",
  "JobStatus": "COMPLETED",
  "NumberOfServicesAccessible": 3,
  "NumberOfServicesNotAccessed": 1
}
POST POST_GetPolicy
{{baseUrl}}/#Action=GetPolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=GetPolicy" {:query-params {:Action ""
                                                                             :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetPolicy"

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}}/?Action=&Version=#Action=GetPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetPolicy");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetPolicy"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=GetPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetPolicy"))
    .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}}/?Action=&Version=#Action=GetPolicy")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=GetPolicy")
  .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}}/?Action=&Version=#Action=GetPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetPolicy';
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}}/?Action=&Version=#Action=GetPolicy',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetPolicy")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=GetPolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=GetPolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetPolicy';
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}}/?Action=&Version=#Action=GetPolicy"]
                                                       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}}/?Action=&Version=#Action=GetPolicy" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetPolicy",
  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}}/?Action=&Version=#Action=GetPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetPolicy');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetPolicy');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetPolicy' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetPolicy' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetPolicy"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetPolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetPolicy")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetPolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=GetPolicy'
http POST '{{baseUrl}}/?Action=&Version=#Action=GetPolicy'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetPolicy")! 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 POST_GetPolicyVersion
{{baseUrl}}/#Action=GetPolicyVersion
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetPolicyVersion");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=GetPolicyVersion" {:query-params {:Action ""
                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetPolicyVersion"

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}}/?Action=&Version=#Action=GetPolicyVersion"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetPolicyVersion");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetPolicyVersion"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=GetPolicyVersion")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetPolicyVersion"))
    .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}}/?Action=&Version=#Action=GetPolicyVersion")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=GetPolicyVersion")
  .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}}/?Action=&Version=#Action=GetPolicyVersion');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetPolicyVersion',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetPolicyVersion';
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}}/?Action=&Version=#Action=GetPolicyVersion',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetPolicyVersion")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=GetPolicyVersion',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=GetPolicyVersion');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetPolicyVersion',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetPolicyVersion';
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}}/?Action=&Version=#Action=GetPolicyVersion"]
                                                       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}}/?Action=&Version=#Action=GetPolicyVersion" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetPolicyVersion",
  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}}/?Action=&Version=#Action=GetPolicyVersion');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetPolicyVersion');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetPolicyVersion');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetPolicyVersion' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetPolicyVersion' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetPolicyVersion"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetPolicyVersion"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetPolicyVersion")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetPolicyVersion";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=GetPolicyVersion'
http POST '{{baseUrl}}/?Action=&Version=#Action=GetPolicyVersion'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetPolicyVersion'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetPolicyVersion")! 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 POST_GetRole
{{baseUrl}}/#Action=GetRole
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetRole");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=GetRole" {:query-params {:Action ""
                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetRole"

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}}/?Action=&Version=#Action=GetRole"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetRole");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetRole"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=GetRole")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetRole"))
    .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}}/?Action=&Version=#Action=GetRole")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=GetRole")
  .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}}/?Action=&Version=#Action=GetRole');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetRole',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetRole';
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}}/?Action=&Version=#Action=GetRole',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetRole")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=GetRole',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=GetRole');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetRole',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetRole';
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}}/?Action=&Version=#Action=GetRole"]
                                                       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}}/?Action=&Version=#Action=GetRole" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetRole",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/?Action=&Version=#Action=GetRole');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetRole');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetRole');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetRole' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetRole' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/?Action=&Version=", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetRole"

querystring = {"Action":"","Version":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetRole"

queryString <- list(
  Action = "",
  Version = ""
)

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetRole")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetRole";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=GetRole'
http POST '{{baseUrl}}/?Action=&Version=#Action=GetRole'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetRole'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetRole")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "Role": {
    "Arn": "arn:aws:iam::123456789012:role/Test-Role",
    "AssumeRolePolicyDocument": "",
    "CreateDate": "2013-04-18T05:01:58Z",
    "MaxSessionDuration": 3600,
    "Path": "/",
    "RoleId": "AROADBQP57FF2AEXAMPLE",
    "RoleLastUsed": {
      "LastUsedDate": "2019-11-18T05:01:58Z",
      "Region": "us-east-1"
    },
    "RoleName": "Test-Role"
  }
}
POST POST_GetRolePolicy
{{baseUrl}}/#Action=GetRolePolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetRolePolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=GetRolePolicy" {:query-params {:Action ""
                                                                                 :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetRolePolicy"

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}}/?Action=&Version=#Action=GetRolePolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetRolePolicy");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetRolePolicy"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=GetRolePolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetRolePolicy"))
    .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}}/?Action=&Version=#Action=GetRolePolicy")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=GetRolePolicy")
  .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}}/?Action=&Version=#Action=GetRolePolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetRolePolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetRolePolicy';
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}}/?Action=&Version=#Action=GetRolePolicy',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetRolePolicy")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=GetRolePolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=GetRolePolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetRolePolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetRolePolicy';
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}}/?Action=&Version=#Action=GetRolePolicy"]
                                                       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}}/?Action=&Version=#Action=GetRolePolicy" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetRolePolicy",
  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}}/?Action=&Version=#Action=GetRolePolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetRolePolicy');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetRolePolicy');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetRolePolicy' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetRolePolicy' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetRolePolicy"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetRolePolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetRolePolicy")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetRolePolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=GetRolePolicy'
http POST '{{baseUrl}}/?Action=&Version=#Action=GetRolePolicy'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetRolePolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetRolePolicy")! 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 POST_GetSAMLProvider
{{baseUrl}}/#Action=GetSAMLProvider
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetSAMLProvider");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=GetSAMLProvider" {:query-params {:Action ""
                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetSAMLProvider"

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}}/?Action=&Version=#Action=GetSAMLProvider"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetSAMLProvider");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetSAMLProvider"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=GetSAMLProvider")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetSAMLProvider"))
    .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}}/?Action=&Version=#Action=GetSAMLProvider")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=GetSAMLProvider")
  .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}}/?Action=&Version=#Action=GetSAMLProvider');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetSAMLProvider',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetSAMLProvider';
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}}/?Action=&Version=#Action=GetSAMLProvider',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetSAMLProvider")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=GetSAMLProvider',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=GetSAMLProvider');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetSAMLProvider',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetSAMLProvider';
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}}/?Action=&Version=#Action=GetSAMLProvider"]
                                                       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}}/?Action=&Version=#Action=GetSAMLProvider" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetSAMLProvider",
  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}}/?Action=&Version=#Action=GetSAMLProvider');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetSAMLProvider');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetSAMLProvider');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetSAMLProvider' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetSAMLProvider' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetSAMLProvider"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetSAMLProvider"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetSAMLProvider")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetSAMLProvider";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=GetSAMLProvider'
http POST '{{baseUrl}}/?Action=&Version=#Action=GetSAMLProvider'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetSAMLProvider'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetSAMLProvider")! 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 POST_GetSSHPublicKey
{{baseUrl}}/#Action=GetSSHPublicKey
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetSSHPublicKey");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=GetSSHPublicKey" {:query-params {:Action ""
                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetSSHPublicKey"

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}}/?Action=&Version=#Action=GetSSHPublicKey"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetSSHPublicKey");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetSSHPublicKey"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=GetSSHPublicKey")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetSSHPublicKey"))
    .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}}/?Action=&Version=#Action=GetSSHPublicKey")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=GetSSHPublicKey")
  .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}}/?Action=&Version=#Action=GetSSHPublicKey');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetSSHPublicKey',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetSSHPublicKey';
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}}/?Action=&Version=#Action=GetSSHPublicKey',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetSSHPublicKey")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=GetSSHPublicKey',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=GetSSHPublicKey');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetSSHPublicKey',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetSSHPublicKey';
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}}/?Action=&Version=#Action=GetSSHPublicKey"]
                                                       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}}/?Action=&Version=#Action=GetSSHPublicKey" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetSSHPublicKey",
  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}}/?Action=&Version=#Action=GetSSHPublicKey');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetSSHPublicKey');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetSSHPublicKey');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetSSHPublicKey' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetSSHPublicKey' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetSSHPublicKey"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetSSHPublicKey"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetSSHPublicKey")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetSSHPublicKey";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=GetSSHPublicKey'
http POST '{{baseUrl}}/?Action=&Version=#Action=GetSSHPublicKey'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetSSHPublicKey'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetSSHPublicKey")! 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 POST_GetServerCertificate
{{baseUrl}}/#Action=GetServerCertificate
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetServerCertificate");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=GetServerCertificate" {:query-params {:Action ""
                                                                                        :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetServerCertificate"

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}}/?Action=&Version=#Action=GetServerCertificate"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetServerCertificate");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetServerCertificate"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=GetServerCertificate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetServerCertificate"))
    .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}}/?Action=&Version=#Action=GetServerCertificate")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=GetServerCertificate")
  .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}}/?Action=&Version=#Action=GetServerCertificate');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetServerCertificate',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetServerCertificate';
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}}/?Action=&Version=#Action=GetServerCertificate',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetServerCertificate")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=GetServerCertificate',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=GetServerCertificate');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetServerCertificate',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetServerCertificate';
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}}/?Action=&Version=#Action=GetServerCertificate"]
                                                       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}}/?Action=&Version=#Action=GetServerCertificate" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetServerCertificate",
  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}}/?Action=&Version=#Action=GetServerCertificate');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetServerCertificate');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetServerCertificate');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetServerCertificate' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetServerCertificate' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetServerCertificate"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetServerCertificate"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetServerCertificate")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetServerCertificate";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=GetServerCertificate'
http POST '{{baseUrl}}/?Action=&Version=#Action=GetServerCertificate'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetServerCertificate'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetServerCertificate")! 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 POST_GetServiceLastAccessedDetails
{{baseUrl}}/#Action=GetServiceLastAccessedDetails
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetails");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=GetServiceLastAccessedDetails" {:query-params {:Action ""
                                                                                                 :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetails"

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}}/?Action=&Version=#Action=GetServiceLastAccessedDetails"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetails");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetails"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetails")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetails"))
    .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}}/?Action=&Version=#Action=GetServiceLastAccessedDetails")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetails")
  .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}}/?Action=&Version=#Action=GetServiceLastAccessedDetails');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetServiceLastAccessedDetails',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetails';
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}}/?Action=&Version=#Action=GetServiceLastAccessedDetails',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetails")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=GetServiceLastAccessedDetails',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=GetServiceLastAccessedDetails');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetServiceLastAccessedDetails',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetails';
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}}/?Action=&Version=#Action=GetServiceLastAccessedDetails"]
                                                       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}}/?Action=&Version=#Action=GetServiceLastAccessedDetails" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetails",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetails');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetServiceLastAccessedDetails');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetServiceLastAccessedDetails');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetails' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetails' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/?Action=&Version=", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetServiceLastAccessedDetails"

querystring = {"Action":"","Version":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetServiceLastAccessedDetails"

queryString <- list(
  Action = "",
  Version = ""
)

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetails")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetServiceLastAccessedDetails";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=GetServiceLastAccessedDetails'
http POST '{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetails'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetails'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetails")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "IsTruncated": false,
  "JobCompletionDate": "2018-10-24T19:47:35.241Z",
  "JobCreationDate": "2018-10-24T19:47:31.466Z",
  "JobStatus": "COMPLETED",
  "ServicesLastAccessed": [
    {
      "LastAuthenticated": "2018-10-24T19:11:00Z",
      "LastAuthenticatedEntity": "arn:aws:iam::123456789012:user/AWSExampleUser01",
      "ServiceName": "AWS Identity and Access Management",
      "ServiceNamespace": "iam",
      "TotalAuthenticatedEntities": 2
    },
    {
      "ServiceName": "Amazon Simple Storage Service",
      "ServiceNamespace": "s3",
      "TotalAuthenticatedEntities": 0
    }
  ]
}
POST POST_GetServiceLastAccessedDetailsWithEntities
{{baseUrl}}/#Action=GetServiceLastAccessedDetailsWithEntities
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=GetServiceLastAccessedDetailsWithEntities" {:query-params {:Action ""
                                                                                                             :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities"

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}}/?Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities"))
    .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}}/?Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities")
  .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}}/?Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetServiceLastAccessedDetailsWithEntities',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities';
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}}/?Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=GetServiceLastAccessedDetailsWithEntities',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=GetServiceLastAccessedDetailsWithEntities');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetServiceLastAccessedDetailsWithEntities',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities';
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}}/?Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities"]
                                                       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}}/?Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetServiceLastAccessedDetailsWithEntities');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetServiceLastAccessedDetailsWithEntities');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/?Action=&Version=", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetServiceLastAccessedDetailsWithEntities"

querystring = {"Action":"","Version":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetServiceLastAccessedDetailsWithEntities"

queryString <- list(
  Action = "",
  Version = ""
)

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetServiceLastAccessedDetailsWithEntities";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities'
http POST '{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetServiceLastAccessedDetailsWithEntities")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "EntityDetailsList": [
    {
      "EntityInfo": {
        "Arn": "arn:aws:iam::123456789012:user/AWSExampleUser01",
        "Id": "AIDAEX2EXAMPLEB6IGCDC",
        "Name": "AWSExampleUser01",
        "Path": "/",
        "Type": "USER"
      },
      "LastAuthenticated": "2018-10-24T19:10:00Z"
    },
    {
      "EntityInfo": {
        "Arn": "arn:aws:iam::123456789012:role/AWSExampleRole01",
        "Id": "AROAEAEXAMPLEIANXSIU4",
        "Name": "AWSExampleRole01",
        "Path": "/",
        "Type": "ROLE"
      }
    }
  ],
  "IsTruncated": false,
  "JobCompletionDate": "2018-10-24T19:47:35.241Z",
  "JobCreationDate": "2018-10-24T19:47:31.466Z",
  "JobStatus": "COMPLETED"
}
POST POST_GetServiceLinkedRoleDeletionStatus
{{baseUrl}}/#Action=GetServiceLinkedRoleDeletionStatus
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=GetServiceLinkedRoleDeletionStatus" {:query-params {:Action ""
                                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus"

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}}/?Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus"))
    .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}}/?Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus")
  .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}}/?Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetServiceLinkedRoleDeletionStatus',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus';
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}}/?Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=GetServiceLinkedRoleDeletionStatus',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=GetServiceLinkedRoleDeletionStatus');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetServiceLinkedRoleDeletionStatus',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus';
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}}/?Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus"]
                                                       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}}/?Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus",
  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}}/?Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetServiceLinkedRoleDeletionStatus');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetServiceLinkedRoleDeletionStatus');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetServiceLinkedRoleDeletionStatus"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetServiceLinkedRoleDeletionStatus"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetServiceLinkedRoleDeletionStatus";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus'
http POST '{{baseUrl}}/?Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetServiceLinkedRoleDeletionStatus")! 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 POST_GetUser
{{baseUrl}}/#Action=GetUser
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetUser");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=GetUser" {:query-params {:Action ""
                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetUser"

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}}/?Action=&Version=#Action=GetUser"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetUser");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetUser"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=GetUser")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetUser"))
    .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}}/?Action=&Version=#Action=GetUser")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=GetUser")
  .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}}/?Action=&Version=#Action=GetUser');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetUser',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetUser';
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}}/?Action=&Version=#Action=GetUser',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetUser")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=GetUser',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=GetUser');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetUser',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetUser';
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}}/?Action=&Version=#Action=GetUser"]
                                                       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}}/?Action=&Version=#Action=GetUser" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetUser",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/?Action=&Version=#Action=GetUser');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetUser');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetUser');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetUser' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetUser' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/?Action=&Version=", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetUser"

querystring = {"Action":"","Version":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetUser"

queryString <- list(
  Action = "",
  Version = ""
)

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetUser")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetUser";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=GetUser'
http POST '{{baseUrl}}/?Action=&Version=#Action=GetUser'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetUser'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetUser")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "User": {
    "Arn": "arn:aws:iam::123456789012:user/Bob",
    "CreateDate": "2012-09-21T23:03:13Z",
    "Path": "/",
    "UserId": "AKIAIOSFODNN7EXAMPLE",
    "UserName": "Bob"
  }
}
POST POST_GetUserPolicy
{{baseUrl}}/#Action=GetUserPolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=GetUserPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=GetUserPolicy" {:query-params {:Action ""
                                                                                 :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=GetUserPolicy"

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}}/?Action=&Version=#Action=GetUserPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=GetUserPolicy");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=GetUserPolicy"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=GetUserPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=GetUserPolicy"))
    .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}}/?Action=&Version=#Action=GetUserPolicy")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=GetUserPolicy")
  .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}}/?Action=&Version=#Action=GetUserPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetUserPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=GetUserPolicy';
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}}/?Action=&Version=#Action=GetUserPolicy',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=GetUserPolicy")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=GetUserPolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=GetUserPolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=GetUserPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=GetUserPolicy';
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}}/?Action=&Version=#Action=GetUserPolicy"]
                                                       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}}/?Action=&Version=#Action=GetUserPolicy" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=GetUserPolicy",
  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}}/?Action=&Version=#Action=GetUserPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=GetUserPolicy');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=GetUserPolicy');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=GetUserPolicy' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=GetUserPolicy' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=GetUserPolicy"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=GetUserPolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=GetUserPolicy")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=GetUserPolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=GetUserPolicy'
http POST '{{baseUrl}}/?Action=&Version=#Action=GetUserPolicy'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=GetUserPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=GetUserPolicy")! 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 POST_ListAccessKeys
{{baseUrl}}/#Action=ListAccessKeys
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListAccessKeys" {:query-params {:Action ""
                                                                                  :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys"

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}}/?Action=&Version=#Action=ListAccessKeys"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys"))
    .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}}/?Action=&Version=#Action=ListAccessKeys")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys")
  .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}}/?Action=&Version=#Action=ListAccessKeys');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListAccessKeys',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys';
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}}/?Action=&Version=#Action=ListAccessKeys',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListAccessKeys',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListAccessKeys');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListAccessKeys',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys';
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}}/?Action=&Version=#Action=ListAccessKeys"]
                                                       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}}/?Action=&Version=#Action=ListAccessKeys" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListAccessKeys');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListAccessKeys');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/?Action=&Version=", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListAccessKeys"

querystring = {"Action":"","Version":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListAccessKeys"

queryString <- list(
  Action = "",
  Version = ""
)

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListAccessKeys";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListAccessKeys'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListAccessKeys")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "AccessKeyMetadata": [
    {
      "AccessKeyId": "AKIA111111111EXAMPLE",
      "CreateDate": "2016-12-01T22:19:58Z",
      "Status": "Active",
      "UserName": "Alice"
    },
    {
      "AccessKeyId": "AKIA222222222EXAMPLE",
      "CreateDate": "2016-12-01T22:20:01Z",
      "Status": "Active",
      "UserName": "Alice"
    }
  ]
}
POST POST_ListAccountAliases
{{baseUrl}}/#Action=ListAccountAliases
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListAccountAliases" {:query-params {:Action ""
                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases"

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}}/?Action=&Version=#Action=ListAccountAliases"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases"))
    .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}}/?Action=&Version=#Action=ListAccountAliases")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases")
  .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}}/?Action=&Version=#Action=ListAccountAliases');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListAccountAliases',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases';
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}}/?Action=&Version=#Action=ListAccountAliases',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListAccountAliases',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListAccountAliases');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListAccountAliases',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases';
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}}/?Action=&Version=#Action=ListAccountAliases"]
                                                       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}}/?Action=&Version=#Action=ListAccountAliases" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListAccountAliases');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListAccountAliases');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/?Action=&Version=", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListAccountAliases"

querystring = {"Action":"","Version":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListAccountAliases"

queryString <- list(
  Action = "",
  Version = ""
)

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListAccountAliases";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListAccountAliases'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListAccountAliases")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "AccountAliases": [
    "exmaple-corporation"
  ]
}
POST POST_ListAttachedGroupPolicies
{{baseUrl}}/#Action=ListAttachedGroupPolicies
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListAttachedGroupPolicies");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListAttachedGroupPolicies" {:query-params {:Action ""
                                                                                             :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListAttachedGroupPolicies"

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}}/?Action=&Version=#Action=ListAttachedGroupPolicies"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListAttachedGroupPolicies");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListAttachedGroupPolicies"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListAttachedGroupPolicies")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListAttachedGroupPolicies"))
    .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}}/?Action=&Version=#Action=ListAttachedGroupPolicies")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListAttachedGroupPolicies")
  .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}}/?Action=&Version=#Action=ListAttachedGroupPolicies');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListAttachedGroupPolicies',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListAttachedGroupPolicies';
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}}/?Action=&Version=#Action=ListAttachedGroupPolicies',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListAttachedGroupPolicies")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListAttachedGroupPolicies',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListAttachedGroupPolicies');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListAttachedGroupPolicies',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListAttachedGroupPolicies';
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}}/?Action=&Version=#Action=ListAttachedGroupPolicies"]
                                                       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}}/?Action=&Version=#Action=ListAttachedGroupPolicies" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListAttachedGroupPolicies",
  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}}/?Action=&Version=#Action=ListAttachedGroupPolicies');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListAttachedGroupPolicies');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListAttachedGroupPolicies');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListAttachedGroupPolicies' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListAttachedGroupPolicies' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListAttachedGroupPolicies"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListAttachedGroupPolicies"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListAttachedGroupPolicies")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListAttachedGroupPolicies";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListAttachedGroupPolicies'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListAttachedGroupPolicies'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListAttachedGroupPolicies'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListAttachedGroupPolicies")! 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 POST_ListAttachedRolePolicies
{{baseUrl}}/#Action=ListAttachedRolePolicies
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListAttachedRolePolicies");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListAttachedRolePolicies" {:query-params {:Action ""
                                                                                            :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListAttachedRolePolicies"

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}}/?Action=&Version=#Action=ListAttachedRolePolicies"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListAttachedRolePolicies");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListAttachedRolePolicies"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListAttachedRolePolicies")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListAttachedRolePolicies"))
    .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}}/?Action=&Version=#Action=ListAttachedRolePolicies")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListAttachedRolePolicies")
  .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}}/?Action=&Version=#Action=ListAttachedRolePolicies');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListAttachedRolePolicies',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListAttachedRolePolicies';
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}}/?Action=&Version=#Action=ListAttachedRolePolicies',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListAttachedRolePolicies")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListAttachedRolePolicies',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListAttachedRolePolicies');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListAttachedRolePolicies',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListAttachedRolePolicies';
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}}/?Action=&Version=#Action=ListAttachedRolePolicies"]
                                                       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}}/?Action=&Version=#Action=ListAttachedRolePolicies" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListAttachedRolePolicies",
  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}}/?Action=&Version=#Action=ListAttachedRolePolicies');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListAttachedRolePolicies');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListAttachedRolePolicies');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListAttachedRolePolicies' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListAttachedRolePolicies' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListAttachedRolePolicies"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListAttachedRolePolicies"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListAttachedRolePolicies")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListAttachedRolePolicies";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListAttachedRolePolicies'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListAttachedRolePolicies'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListAttachedRolePolicies'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListAttachedRolePolicies")! 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 POST_ListAttachedUserPolicies
{{baseUrl}}/#Action=ListAttachedUserPolicies
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListAttachedUserPolicies");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListAttachedUserPolicies" {:query-params {:Action ""
                                                                                            :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListAttachedUserPolicies"

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}}/?Action=&Version=#Action=ListAttachedUserPolicies"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListAttachedUserPolicies");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListAttachedUserPolicies"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListAttachedUserPolicies")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListAttachedUserPolicies"))
    .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}}/?Action=&Version=#Action=ListAttachedUserPolicies")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListAttachedUserPolicies")
  .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}}/?Action=&Version=#Action=ListAttachedUserPolicies');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListAttachedUserPolicies',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListAttachedUserPolicies';
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}}/?Action=&Version=#Action=ListAttachedUserPolicies',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListAttachedUserPolicies")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListAttachedUserPolicies',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListAttachedUserPolicies');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListAttachedUserPolicies',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListAttachedUserPolicies';
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}}/?Action=&Version=#Action=ListAttachedUserPolicies"]
                                                       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}}/?Action=&Version=#Action=ListAttachedUserPolicies" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListAttachedUserPolicies",
  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}}/?Action=&Version=#Action=ListAttachedUserPolicies');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListAttachedUserPolicies');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListAttachedUserPolicies');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListAttachedUserPolicies' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListAttachedUserPolicies' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListAttachedUserPolicies"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListAttachedUserPolicies"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListAttachedUserPolicies")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListAttachedUserPolicies";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListAttachedUserPolicies'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListAttachedUserPolicies'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListAttachedUserPolicies'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListAttachedUserPolicies")! 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 POST_ListEntitiesForPolicy
{{baseUrl}}/#Action=ListEntitiesForPolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListEntitiesForPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListEntitiesForPolicy" {:query-params {:Action ""
                                                                                         :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListEntitiesForPolicy"

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}}/?Action=&Version=#Action=ListEntitiesForPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListEntitiesForPolicy");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListEntitiesForPolicy"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListEntitiesForPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListEntitiesForPolicy"))
    .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}}/?Action=&Version=#Action=ListEntitiesForPolicy")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListEntitiesForPolicy")
  .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}}/?Action=&Version=#Action=ListEntitiesForPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListEntitiesForPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListEntitiesForPolicy';
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}}/?Action=&Version=#Action=ListEntitiesForPolicy',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListEntitiesForPolicy")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListEntitiesForPolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListEntitiesForPolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListEntitiesForPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListEntitiesForPolicy';
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}}/?Action=&Version=#Action=ListEntitiesForPolicy"]
                                                       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}}/?Action=&Version=#Action=ListEntitiesForPolicy" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListEntitiesForPolicy",
  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}}/?Action=&Version=#Action=ListEntitiesForPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListEntitiesForPolicy');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListEntitiesForPolicy');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListEntitiesForPolicy' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListEntitiesForPolicy' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListEntitiesForPolicy"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListEntitiesForPolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListEntitiesForPolicy")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListEntitiesForPolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListEntitiesForPolicy'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListEntitiesForPolicy'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListEntitiesForPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListEntitiesForPolicy")! 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 POST_ListGroupPolicies
{{baseUrl}}/#Action=ListGroupPolicies
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListGroupPolicies");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListGroupPolicies" {:query-params {:Action ""
                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListGroupPolicies"

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}}/?Action=&Version=#Action=ListGroupPolicies"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListGroupPolicies");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListGroupPolicies"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListGroupPolicies")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListGroupPolicies"))
    .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}}/?Action=&Version=#Action=ListGroupPolicies")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListGroupPolicies")
  .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}}/?Action=&Version=#Action=ListGroupPolicies');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListGroupPolicies',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListGroupPolicies';
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}}/?Action=&Version=#Action=ListGroupPolicies',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListGroupPolicies")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListGroupPolicies',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListGroupPolicies');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListGroupPolicies',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListGroupPolicies';
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}}/?Action=&Version=#Action=ListGroupPolicies"]
                                                       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}}/?Action=&Version=#Action=ListGroupPolicies" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListGroupPolicies",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/?Action=&Version=#Action=ListGroupPolicies');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListGroupPolicies');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListGroupPolicies');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListGroupPolicies' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListGroupPolicies' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/?Action=&Version=", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListGroupPolicies"

querystring = {"Action":"","Version":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListGroupPolicies"

queryString <- list(
  Action = "",
  Version = ""
)

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListGroupPolicies")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListGroupPolicies";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListGroupPolicies'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListGroupPolicies'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListGroupPolicies'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListGroupPolicies")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "PolicyNames": [
    "AdminRoot",
    "KeyPolicy"
  ]
}
POST POST_ListGroups
{{baseUrl}}/#Action=ListGroups
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListGroups");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListGroups" {:query-params {:Action ""
                                                                              :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListGroups"

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}}/?Action=&Version=#Action=ListGroups"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListGroups");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListGroups"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListGroups")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListGroups"))
    .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}}/?Action=&Version=#Action=ListGroups")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListGroups")
  .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}}/?Action=&Version=#Action=ListGroups');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListGroups',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListGroups';
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}}/?Action=&Version=#Action=ListGroups',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListGroups")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListGroups',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListGroups');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListGroups',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListGroups';
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}}/?Action=&Version=#Action=ListGroups"]
                                                       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}}/?Action=&Version=#Action=ListGroups" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListGroups",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/?Action=&Version=#Action=ListGroups');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListGroups');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListGroups');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListGroups' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListGroups' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/?Action=&Version=", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListGroups"

querystring = {"Action":"","Version":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListGroups"

queryString <- list(
  Action = "",
  Version = ""
)

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListGroups")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListGroups";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListGroups'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListGroups'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListGroups'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListGroups")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "Groups": [
    {
      "Arn": "arn:aws:iam::123456789012:group/Admins",
      "CreateDate": "2016-12-15T21:40:08.121Z",
      "GroupId": "AGPA1111111111EXAMPLE",
      "GroupName": "Admins",
      "Path": "/division_abc/subdivision_xyz/"
    },
    {
      "Arn": "arn:aws:iam::123456789012:group/division_abc/subdivision_xyz/product_1234/engineering/Test",
      "CreateDate": "2016-11-30T14:10:01.156Z",
      "GroupId": "AGP22222222222EXAMPLE",
      "GroupName": "Test",
      "Path": "/division_abc/subdivision_xyz/product_1234/engineering/"
    },
    {
      "Arn": "arn:aws:iam::123456789012:group/division_abc/subdivision_xyz/product_1234/Managers",
      "CreateDate": "2016-06-12T20:14:52.032Z",
      "GroupId": "AGPI3333333333EXAMPLE",
      "GroupName": "Managers",
      "Path": "/division_abc/subdivision_xyz/product_1234/"
    }
  ]
}
POST POST_ListGroupsForUser
{{baseUrl}}/#Action=ListGroupsForUser
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListGroupsForUser");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListGroupsForUser" {:query-params {:Action ""
                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListGroupsForUser"

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}}/?Action=&Version=#Action=ListGroupsForUser"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListGroupsForUser");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListGroupsForUser"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListGroupsForUser")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListGroupsForUser"))
    .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}}/?Action=&Version=#Action=ListGroupsForUser")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListGroupsForUser")
  .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}}/?Action=&Version=#Action=ListGroupsForUser');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListGroupsForUser',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListGroupsForUser';
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}}/?Action=&Version=#Action=ListGroupsForUser',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListGroupsForUser")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListGroupsForUser',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListGroupsForUser');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListGroupsForUser',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListGroupsForUser';
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}}/?Action=&Version=#Action=ListGroupsForUser"]
                                                       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}}/?Action=&Version=#Action=ListGroupsForUser" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListGroupsForUser",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/?Action=&Version=#Action=ListGroupsForUser');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListGroupsForUser');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListGroupsForUser');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListGroupsForUser' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListGroupsForUser' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/?Action=&Version=", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListGroupsForUser"

querystring = {"Action":"","Version":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListGroupsForUser"

queryString <- list(
  Action = "",
  Version = ""
)

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListGroupsForUser")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListGroupsForUser";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListGroupsForUser'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListGroupsForUser'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListGroupsForUser'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListGroupsForUser")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "Groups": [
    {
      "Arn": "arn:aws:iam::123456789012:group/division_abc/subdivision_xyz/product_1234/engineering/Test",
      "CreateDate": "2016-11-30T14:10:01.156Z",
      "GroupId": "AGP2111111111EXAMPLE",
      "GroupName": "Test",
      "Path": "/division_abc/subdivision_xyz/product_1234/engineering/"
    },
    {
      "Arn": "arn:aws:iam::123456789012:group/division_abc/subdivision_xyz/product_1234/Managers",
      "CreateDate": "2016-06-12T20:14:52.032Z",
      "GroupId": "AGPI222222222SEXAMPLE",
      "GroupName": "Managers",
      "Path": "/division_abc/subdivision_xyz/product_1234/"
    }
  ]
}
POST POST_ListInstanceProfileTags
{{baseUrl}}/#Action=ListInstanceProfileTags
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfileTags");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListInstanceProfileTags" {:query-params {:Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfileTags"

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}}/?Action=&Version=#Action=ListInstanceProfileTags"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfileTags");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfileTags"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfileTags")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfileTags"))
    .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}}/?Action=&Version=#Action=ListInstanceProfileTags")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfileTags")
  .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}}/?Action=&Version=#Action=ListInstanceProfileTags');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListInstanceProfileTags',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfileTags';
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}}/?Action=&Version=#Action=ListInstanceProfileTags',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfileTags")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListInstanceProfileTags',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListInstanceProfileTags');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListInstanceProfileTags',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfileTags';
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}}/?Action=&Version=#Action=ListInstanceProfileTags"]
                                                       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}}/?Action=&Version=#Action=ListInstanceProfileTags" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfileTags",
  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}}/?Action=&Version=#Action=ListInstanceProfileTags');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListInstanceProfileTags');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListInstanceProfileTags');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfileTags' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfileTags' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListInstanceProfileTags"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListInstanceProfileTags"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfileTags")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListInstanceProfileTags";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListInstanceProfileTags'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfileTags'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfileTags'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfileTags")! 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 POST_ListInstanceProfiles
{{baseUrl}}/#Action=ListInstanceProfiles
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListInstanceProfiles" {:query-params {:Action ""
                                                                                        :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles"

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}}/?Action=&Version=#Action=ListInstanceProfiles"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles"))
    .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}}/?Action=&Version=#Action=ListInstanceProfiles")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles")
  .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}}/?Action=&Version=#Action=ListInstanceProfiles');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListInstanceProfiles',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles';
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}}/?Action=&Version=#Action=ListInstanceProfiles',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListInstanceProfiles',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListInstanceProfiles');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListInstanceProfiles',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles';
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}}/?Action=&Version=#Action=ListInstanceProfiles"]
                                                       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}}/?Action=&Version=#Action=ListInstanceProfiles" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles",
  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}}/?Action=&Version=#Action=ListInstanceProfiles');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListInstanceProfiles');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListInstanceProfiles');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListInstanceProfiles"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListInstanceProfiles"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListInstanceProfiles";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListInstanceProfiles'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfiles")! 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 POST_ListInstanceProfilesForRole
{{baseUrl}}/#Action=ListInstanceProfilesForRole
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfilesForRole");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListInstanceProfilesForRole" {:query-params {:Action ""
                                                                                               :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfilesForRole"

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}}/?Action=&Version=#Action=ListInstanceProfilesForRole"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfilesForRole");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfilesForRole"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfilesForRole")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfilesForRole"))
    .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}}/?Action=&Version=#Action=ListInstanceProfilesForRole")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfilesForRole")
  .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}}/?Action=&Version=#Action=ListInstanceProfilesForRole');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListInstanceProfilesForRole',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfilesForRole';
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}}/?Action=&Version=#Action=ListInstanceProfilesForRole',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfilesForRole")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListInstanceProfilesForRole',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListInstanceProfilesForRole');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListInstanceProfilesForRole',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfilesForRole';
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}}/?Action=&Version=#Action=ListInstanceProfilesForRole"]
                                                       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}}/?Action=&Version=#Action=ListInstanceProfilesForRole" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfilesForRole",
  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}}/?Action=&Version=#Action=ListInstanceProfilesForRole');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListInstanceProfilesForRole');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListInstanceProfilesForRole');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfilesForRole' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfilesForRole' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListInstanceProfilesForRole"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListInstanceProfilesForRole"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfilesForRole")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListInstanceProfilesForRole";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListInstanceProfilesForRole'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfilesForRole'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfilesForRole'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListInstanceProfilesForRole")! 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 POST_ListMFADeviceTags
{{baseUrl}}/#Action=ListMFADeviceTags
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListMFADeviceTags");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListMFADeviceTags" {:query-params {:Action ""
                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListMFADeviceTags"

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}}/?Action=&Version=#Action=ListMFADeviceTags"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListMFADeviceTags");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListMFADeviceTags"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListMFADeviceTags")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListMFADeviceTags"))
    .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}}/?Action=&Version=#Action=ListMFADeviceTags")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListMFADeviceTags")
  .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}}/?Action=&Version=#Action=ListMFADeviceTags');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListMFADeviceTags',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListMFADeviceTags';
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}}/?Action=&Version=#Action=ListMFADeviceTags',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListMFADeviceTags")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListMFADeviceTags',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListMFADeviceTags');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListMFADeviceTags',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListMFADeviceTags';
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}}/?Action=&Version=#Action=ListMFADeviceTags"]
                                                       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}}/?Action=&Version=#Action=ListMFADeviceTags" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListMFADeviceTags",
  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}}/?Action=&Version=#Action=ListMFADeviceTags');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListMFADeviceTags');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListMFADeviceTags');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListMFADeviceTags' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListMFADeviceTags' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListMFADeviceTags"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListMFADeviceTags"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListMFADeviceTags")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListMFADeviceTags";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListMFADeviceTags'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListMFADeviceTags'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListMFADeviceTags'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListMFADeviceTags")! 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 POST_ListMFADevices
{{baseUrl}}/#Action=ListMFADevices
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListMFADevices");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListMFADevices" {:query-params {:Action ""
                                                                                  :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListMFADevices"

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}}/?Action=&Version=#Action=ListMFADevices"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListMFADevices");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListMFADevices"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListMFADevices")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListMFADevices"))
    .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}}/?Action=&Version=#Action=ListMFADevices")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListMFADevices")
  .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}}/?Action=&Version=#Action=ListMFADevices');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListMFADevices',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListMFADevices';
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}}/?Action=&Version=#Action=ListMFADevices',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListMFADevices")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListMFADevices',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListMFADevices');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListMFADevices',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListMFADevices';
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}}/?Action=&Version=#Action=ListMFADevices"]
                                                       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}}/?Action=&Version=#Action=ListMFADevices" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListMFADevices",
  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}}/?Action=&Version=#Action=ListMFADevices');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListMFADevices');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListMFADevices');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListMFADevices' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListMFADevices' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListMFADevices"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListMFADevices"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListMFADevices")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListMFADevices";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListMFADevices'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListMFADevices'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListMFADevices'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListMFADevices")! 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 POST_ListOpenIDConnectProviderTags
{{baseUrl}}/#Action=ListOpenIDConnectProviderTags
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviderTags");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListOpenIDConnectProviderTags" {:query-params {:Action ""
                                                                                                 :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviderTags"

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}}/?Action=&Version=#Action=ListOpenIDConnectProviderTags"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviderTags");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviderTags"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviderTags")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviderTags"))
    .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}}/?Action=&Version=#Action=ListOpenIDConnectProviderTags")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviderTags")
  .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}}/?Action=&Version=#Action=ListOpenIDConnectProviderTags');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListOpenIDConnectProviderTags',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviderTags';
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}}/?Action=&Version=#Action=ListOpenIDConnectProviderTags',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviderTags")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListOpenIDConnectProviderTags',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListOpenIDConnectProviderTags');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListOpenIDConnectProviderTags',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviderTags';
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}}/?Action=&Version=#Action=ListOpenIDConnectProviderTags"]
                                                       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}}/?Action=&Version=#Action=ListOpenIDConnectProviderTags" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviderTags",
  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}}/?Action=&Version=#Action=ListOpenIDConnectProviderTags');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListOpenIDConnectProviderTags');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListOpenIDConnectProviderTags');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviderTags' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviderTags' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListOpenIDConnectProviderTags"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListOpenIDConnectProviderTags"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviderTags")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListOpenIDConnectProviderTags";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListOpenIDConnectProviderTags'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviderTags'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviderTags'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviderTags")! 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 POST_ListOpenIDConnectProviders
{{baseUrl}}/#Action=ListOpenIDConnectProviders
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListOpenIDConnectProviders" {:query-params {:Action ""
                                                                                              :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders"

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}}/?Action=&Version=#Action=ListOpenIDConnectProviders"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders"))
    .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}}/?Action=&Version=#Action=ListOpenIDConnectProviders")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders")
  .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}}/?Action=&Version=#Action=ListOpenIDConnectProviders');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListOpenIDConnectProviders',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders';
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}}/?Action=&Version=#Action=ListOpenIDConnectProviders',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListOpenIDConnectProviders',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListOpenIDConnectProviders');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListOpenIDConnectProviders',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders';
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}}/?Action=&Version=#Action=ListOpenIDConnectProviders"]
                                                       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}}/?Action=&Version=#Action=ListOpenIDConnectProviders" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders",
  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}}/?Action=&Version=#Action=ListOpenIDConnectProviders');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListOpenIDConnectProviders');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListOpenIDConnectProviders');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListOpenIDConnectProviders"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListOpenIDConnectProviders"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListOpenIDConnectProviders";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListOpenIDConnectProviders'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListOpenIDConnectProviders")! 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 POST_ListPolicies
{{baseUrl}}/#Action=ListPolicies
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListPolicies");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListPolicies" {:query-params {:Action ""
                                                                                :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListPolicies"

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}}/?Action=&Version=#Action=ListPolicies"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListPolicies");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListPolicies"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListPolicies")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListPolicies"))
    .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}}/?Action=&Version=#Action=ListPolicies")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListPolicies")
  .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}}/?Action=&Version=#Action=ListPolicies');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListPolicies',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListPolicies';
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}}/?Action=&Version=#Action=ListPolicies',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListPolicies")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListPolicies',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListPolicies');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListPolicies',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListPolicies';
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}}/?Action=&Version=#Action=ListPolicies"]
                                                       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}}/?Action=&Version=#Action=ListPolicies" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListPolicies",
  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}}/?Action=&Version=#Action=ListPolicies');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListPolicies');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListPolicies');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListPolicies' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListPolicies' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListPolicies"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListPolicies"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListPolicies")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListPolicies";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListPolicies'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListPolicies'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListPolicies'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListPolicies")! 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 POST_ListPoliciesGrantingServiceAccess
{{baseUrl}}/#Action=ListPoliciesGrantingServiceAccess
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListPoliciesGrantingServiceAccess");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListPoliciesGrantingServiceAccess" {:query-params {:Action ""
                                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListPoliciesGrantingServiceAccess"

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}}/?Action=&Version=#Action=ListPoliciesGrantingServiceAccess"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListPoliciesGrantingServiceAccess");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListPoliciesGrantingServiceAccess"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListPoliciesGrantingServiceAccess")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListPoliciesGrantingServiceAccess"))
    .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}}/?Action=&Version=#Action=ListPoliciesGrantingServiceAccess")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListPoliciesGrantingServiceAccess")
  .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}}/?Action=&Version=#Action=ListPoliciesGrantingServiceAccess');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListPoliciesGrantingServiceAccess',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListPoliciesGrantingServiceAccess';
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}}/?Action=&Version=#Action=ListPoliciesGrantingServiceAccess',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListPoliciesGrantingServiceAccess")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListPoliciesGrantingServiceAccess',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListPoliciesGrantingServiceAccess');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListPoliciesGrantingServiceAccess',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListPoliciesGrantingServiceAccess';
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}}/?Action=&Version=#Action=ListPoliciesGrantingServiceAccess"]
                                                       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}}/?Action=&Version=#Action=ListPoliciesGrantingServiceAccess" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListPoliciesGrantingServiceAccess",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/?Action=&Version=#Action=ListPoliciesGrantingServiceAccess');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListPoliciesGrantingServiceAccess');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListPoliciesGrantingServiceAccess');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListPoliciesGrantingServiceAccess' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListPoliciesGrantingServiceAccess' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/?Action=&Version=", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListPoliciesGrantingServiceAccess"

querystring = {"Action":"","Version":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListPoliciesGrantingServiceAccess"

queryString <- list(
  Action = "",
  Version = ""
)

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListPoliciesGrantingServiceAccess")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListPoliciesGrantingServiceAccess";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListPoliciesGrantingServiceAccess'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListPoliciesGrantingServiceAccess'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListPoliciesGrantingServiceAccess'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListPoliciesGrantingServiceAccess")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "IsTruncated": false,
  "PoliciesGrantingServiceAccess": [
    {
      "Policies": [
        {
          "PolicyArn": "arn:aws:iam::123456789012:policy/ExampleIamPolicy",
          "PolicyName": "ExampleIamPolicy",
          "PolicyType": "MANAGED"
        },
        {
          "EntityName": "AWSExampleGroup1",
          "EntityType": "GROUP",
          "PolicyName": "ExampleGroup1Policy",
          "PolicyType": "INLINE"
        }
      ],
      "ServiceNamespace": "iam"
    },
    {
      "Policies": [
        {
          "PolicyArn": "arn:aws:iam::123456789012:policy/ExampleEc2Policy",
          "PolicyName": "ExampleEc2Policy",
          "PolicyType": "MANAGED"
        }
      ],
      "ServiceNamespace": "ec2"
    }
  ]
}
POST POST_ListPolicyTags
{{baseUrl}}/#Action=ListPolicyTags
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListPolicyTags");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListPolicyTags" {:query-params {:Action ""
                                                                                  :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListPolicyTags"

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}}/?Action=&Version=#Action=ListPolicyTags"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListPolicyTags");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListPolicyTags"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListPolicyTags")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListPolicyTags"))
    .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}}/?Action=&Version=#Action=ListPolicyTags")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListPolicyTags")
  .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}}/?Action=&Version=#Action=ListPolicyTags');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListPolicyTags',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListPolicyTags';
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}}/?Action=&Version=#Action=ListPolicyTags',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListPolicyTags")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListPolicyTags',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListPolicyTags');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListPolicyTags',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListPolicyTags';
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}}/?Action=&Version=#Action=ListPolicyTags"]
                                                       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}}/?Action=&Version=#Action=ListPolicyTags" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListPolicyTags",
  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}}/?Action=&Version=#Action=ListPolicyTags');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListPolicyTags');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListPolicyTags');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListPolicyTags' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListPolicyTags' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListPolicyTags"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListPolicyTags"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListPolicyTags")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListPolicyTags";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListPolicyTags'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListPolicyTags'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListPolicyTags'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListPolicyTags")! 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 POST_ListPolicyVersions
{{baseUrl}}/#Action=ListPolicyVersions
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListPolicyVersions");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListPolicyVersions" {:query-params {:Action ""
                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListPolicyVersions"

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}}/?Action=&Version=#Action=ListPolicyVersions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListPolicyVersions");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListPolicyVersions"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListPolicyVersions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListPolicyVersions"))
    .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}}/?Action=&Version=#Action=ListPolicyVersions")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListPolicyVersions")
  .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}}/?Action=&Version=#Action=ListPolicyVersions');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListPolicyVersions',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListPolicyVersions';
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}}/?Action=&Version=#Action=ListPolicyVersions',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListPolicyVersions")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListPolicyVersions',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListPolicyVersions');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListPolicyVersions',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListPolicyVersions';
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}}/?Action=&Version=#Action=ListPolicyVersions"]
                                                       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}}/?Action=&Version=#Action=ListPolicyVersions" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListPolicyVersions",
  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}}/?Action=&Version=#Action=ListPolicyVersions');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListPolicyVersions');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListPolicyVersions');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListPolicyVersions' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListPolicyVersions' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListPolicyVersions"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListPolicyVersions"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListPolicyVersions")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListPolicyVersions";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListPolicyVersions'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListPolicyVersions'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListPolicyVersions'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListPolicyVersions")! 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 POST_ListRolePolicies
{{baseUrl}}/#Action=ListRolePolicies
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListRolePolicies");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListRolePolicies" {:query-params {:Action ""
                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListRolePolicies"

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}}/?Action=&Version=#Action=ListRolePolicies"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListRolePolicies");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListRolePolicies"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListRolePolicies")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListRolePolicies"))
    .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}}/?Action=&Version=#Action=ListRolePolicies")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListRolePolicies")
  .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}}/?Action=&Version=#Action=ListRolePolicies');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListRolePolicies',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListRolePolicies';
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}}/?Action=&Version=#Action=ListRolePolicies',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListRolePolicies")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListRolePolicies',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListRolePolicies');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListRolePolicies',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListRolePolicies';
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}}/?Action=&Version=#Action=ListRolePolicies"]
                                                       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}}/?Action=&Version=#Action=ListRolePolicies" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListRolePolicies",
  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}}/?Action=&Version=#Action=ListRolePolicies');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListRolePolicies');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListRolePolicies');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListRolePolicies' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListRolePolicies' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListRolePolicies"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListRolePolicies"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListRolePolicies")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListRolePolicies";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListRolePolicies'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListRolePolicies'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListRolePolicies'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListRolePolicies")! 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 POST_ListRoleTags
{{baseUrl}}/#Action=ListRoleTags
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListRoleTags");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListRoleTags" {:query-params {:Action ""
                                                                                :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListRoleTags"

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}}/?Action=&Version=#Action=ListRoleTags"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListRoleTags");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListRoleTags"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListRoleTags")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListRoleTags"))
    .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}}/?Action=&Version=#Action=ListRoleTags")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListRoleTags")
  .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}}/?Action=&Version=#Action=ListRoleTags');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListRoleTags',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListRoleTags';
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}}/?Action=&Version=#Action=ListRoleTags',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListRoleTags")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListRoleTags',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListRoleTags');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListRoleTags',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListRoleTags';
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}}/?Action=&Version=#Action=ListRoleTags"]
                                                       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}}/?Action=&Version=#Action=ListRoleTags" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListRoleTags",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/?Action=&Version=#Action=ListRoleTags');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListRoleTags');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListRoleTags');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListRoleTags' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListRoleTags' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/?Action=&Version=", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListRoleTags"

querystring = {"Action":"","Version":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListRoleTags"

queryString <- list(
  Action = "",
  Version = ""
)

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListRoleTags")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListRoleTags";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListRoleTags'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListRoleTags'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListRoleTags'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListRoleTags")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "IsTruncated": false,
  "Tags": [
    {
      "Key": "Dept",
      "Value": "12345"
    },
    {
      "Key": "Team",
      "Value": "Accounting"
    }
  ]
}
POST POST_ListRoles
{{baseUrl}}/#Action=ListRoles
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListRoles");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListRoles" {:query-params {:Action ""
                                                                             :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListRoles"

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}}/?Action=&Version=#Action=ListRoles"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListRoles");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListRoles"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListRoles")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListRoles"))
    .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}}/?Action=&Version=#Action=ListRoles")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListRoles")
  .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}}/?Action=&Version=#Action=ListRoles');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListRoles',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListRoles';
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}}/?Action=&Version=#Action=ListRoles',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListRoles")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListRoles',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListRoles');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListRoles',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListRoles';
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}}/?Action=&Version=#Action=ListRoles"]
                                                       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}}/?Action=&Version=#Action=ListRoles" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListRoles",
  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}}/?Action=&Version=#Action=ListRoles');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListRoles');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListRoles');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListRoles' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListRoles' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListRoles"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListRoles"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListRoles")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListRoles";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListRoles'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListRoles'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListRoles'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListRoles")! 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 POST_ListSAMLProviderTags
{{baseUrl}}/#Action=ListSAMLProviderTags
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviderTags");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListSAMLProviderTags" {:query-params {:Action ""
                                                                                        :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviderTags"

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}}/?Action=&Version=#Action=ListSAMLProviderTags"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviderTags");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviderTags"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviderTags")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviderTags"))
    .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}}/?Action=&Version=#Action=ListSAMLProviderTags")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviderTags")
  .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}}/?Action=&Version=#Action=ListSAMLProviderTags');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListSAMLProviderTags',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviderTags';
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}}/?Action=&Version=#Action=ListSAMLProviderTags',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviderTags")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListSAMLProviderTags',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListSAMLProviderTags');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListSAMLProviderTags',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviderTags';
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}}/?Action=&Version=#Action=ListSAMLProviderTags"]
                                                       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}}/?Action=&Version=#Action=ListSAMLProviderTags" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviderTags",
  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}}/?Action=&Version=#Action=ListSAMLProviderTags');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListSAMLProviderTags');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListSAMLProviderTags');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviderTags' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviderTags' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListSAMLProviderTags"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListSAMLProviderTags"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviderTags")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListSAMLProviderTags";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListSAMLProviderTags'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviderTags'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviderTags'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviderTags")! 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 POST_ListSAMLProviders
{{baseUrl}}/#Action=ListSAMLProviders
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListSAMLProviders" {:query-params {:Action ""
                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders"

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}}/?Action=&Version=#Action=ListSAMLProviders"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders"))
    .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}}/?Action=&Version=#Action=ListSAMLProviders")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders")
  .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}}/?Action=&Version=#Action=ListSAMLProviders');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListSAMLProviders',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders';
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}}/?Action=&Version=#Action=ListSAMLProviders',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListSAMLProviders',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListSAMLProviders');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListSAMLProviders',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders';
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}}/?Action=&Version=#Action=ListSAMLProviders"]
                                                       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}}/?Action=&Version=#Action=ListSAMLProviders" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders",
  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}}/?Action=&Version=#Action=ListSAMLProviders');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListSAMLProviders');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListSAMLProviders');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListSAMLProviders"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListSAMLProviders"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListSAMLProviders";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListSAMLProviders'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListSAMLProviders")! 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 POST_ListSSHPublicKeys
{{baseUrl}}/#Action=ListSSHPublicKeys
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListSSHPublicKeys" {:query-params {:Action ""
                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys"

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}}/?Action=&Version=#Action=ListSSHPublicKeys"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys"))
    .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}}/?Action=&Version=#Action=ListSSHPublicKeys")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys")
  .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}}/?Action=&Version=#Action=ListSSHPublicKeys');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListSSHPublicKeys',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys';
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}}/?Action=&Version=#Action=ListSSHPublicKeys',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListSSHPublicKeys',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListSSHPublicKeys');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListSSHPublicKeys',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys';
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}}/?Action=&Version=#Action=ListSSHPublicKeys"]
                                                       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}}/?Action=&Version=#Action=ListSSHPublicKeys" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys",
  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}}/?Action=&Version=#Action=ListSSHPublicKeys');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListSSHPublicKeys');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListSSHPublicKeys');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListSSHPublicKeys"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListSSHPublicKeys"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListSSHPublicKeys";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListSSHPublicKeys'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListSSHPublicKeys")! 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 POST_ListServerCertificateTags
{{baseUrl}}/#Action=ListServerCertificateTags
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListServerCertificateTags");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListServerCertificateTags" {:query-params {:Action ""
                                                                                             :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListServerCertificateTags"

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}}/?Action=&Version=#Action=ListServerCertificateTags"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListServerCertificateTags");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListServerCertificateTags"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListServerCertificateTags")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListServerCertificateTags"))
    .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}}/?Action=&Version=#Action=ListServerCertificateTags")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListServerCertificateTags")
  .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}}/?Action=&Version=#Action=ListServerCertificateTags');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListServerCertificateTags',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListServerCertificateTags';
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}}/?Action=&Version=#Action=ListServerCertificateTags',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListServerCertificateTags")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListServerCertificateTags',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListServerCertificateTags');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListServerCertificateTags',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListServerCertificateTags';
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}}/?Action=&Version=#Action=ListServerCertificateTags"]
                                                       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}}/?Action=&Version=#Action=ListServerCertificateTags" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListServerCertificateTags",
  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}}/?Action=&Version=#Action=ListServerCertificateTags');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListServerCertificateTags');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListServerCertificateTags');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListServerCertificateTags' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListServerCertificateTags' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListServerCertificateTags"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListServerCertificateTags"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListServerCertificateTags")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListServerCertificateTags";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListServerCertificateTags'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListServerCertificateTags'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListServerCertificateTags'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListServerCertificateTags")! 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 POST_ListServerCertificates
{{baseUrl}}/#Action=ListServerCertificates
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListServerCertificates" {:query-params {:Action ""
                                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates"

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}}/?Action=&Version=#Action=ListServerCertificates"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates"))
    .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}}/?Action=&Version=#Action=ListServerCertificates")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates")
  .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}}/?Action=&Version=#Action=ListServerCertificates');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListServerCertificates',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates';
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}}/?Action=&Version=#Action=ListServerCertificates',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListServerCertificates',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListServerCertificates');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListServerCertificates',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates';
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}}/?Action=&Version=#Action=ListServerCertificates"]
                                                       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}}/?Action=&Version=#Action=ListServerCertificates" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates",
  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}}/?Action=&Version=#Action=ListServerCertificates');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListServerCertificates');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListServerCertificates');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListServerCertificates"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListServerCertificates"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListServerCertificates";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListServerCertificates'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListServerCertificates")! 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 POST_ListServiceSpecificCredentials
{{baseUrl}}/#Action=ListServiceSpecificCredentials
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListServiceSpecificCredentials" {:query-params {:Action ""
                                                                                                  :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials"

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}}/?Action=&Version=#Action=ListServiceSpecificCredentials"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials"))
    .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}}/?Action=&Version=#Action=ListServiceSpecificCredentials")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials")
  .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}}/?Action=&Version=#Action=ListServiceSpecificCredentials');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListServiceSpecificCredentials',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials';
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}}/?Action=&Version=#Action=ListServiceSpecificCredentials',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListServiceSpecificCredentials',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListServiceSpecificCredentials');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListServiceSpecificCredentials',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials';
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}}/?Action=&Version=#Action=ListServiceSpecificCredentials"]
                                                       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}}/?Action=&Version=#Action=ListServiceSpecificCredentials" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials",
  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}}/?Action=&Version=#Action=ListServiceSpecificCredentials');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListServiceSpecificCredentials');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListServiceSpecificCredentials');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListServiceSpecificCredentials"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListServiceSpecificCredentials"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListServiceSpecificCredentials";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListServiceSpecificCredentials'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListServiceSpecificCredentials")! 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 POST_ListSigningCertificates
{{baseUrl}}/#Action=ListSigningCertificates
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListSigningCertificates" {:query-params {:Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates"

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}}/?Action=&Version=#Action=ListSigningCertificates"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates"))
    .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}}/?Action=&Version=#Action=ListSigningCertificates")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates")
  .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}}/?Action=&Version=#Action=ListSigningCertificates');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListSigningCertificates',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates';
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}}/?Action=&Version=#Action=ListSigningCertificates',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListSigningCertificates',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListSigningCertificates');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListSigningCertificates',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates';
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}}/?Action=&Version=#Action=ListSigningCertificates"]
                                                       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}}/?Action=&Version=#Action=ListSigningCertificates" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListSigningCertificates');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListSigningCertificates');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/?Action=&Version=", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListSigningCertificates"

querystring = {"Action":"","Version":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListSigningCertificates"

queryString <- list(
  Action = "",
  Version = ""
)

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListSigningCertificates";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListSigningCertificates'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListSigningCertificates")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "Certificates": [
    {
      "CertificateBody": "-----BEGIN CERTIFICATE----------END CERTIFICATE-----",
      "CertificateId": "TA7SMP42TDN5Z26OBPJE7EXAMPLE",
      "Status": "Active",
      "UploadDate": "2013-06-06T21:40:08Z",
      "UserName": "Bob"
    }
  ]
}
POST POST_ListUserPolicies
{{baseUrl}}/#Action=ListUserPolicies
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListUserPolicies");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListUserPolicies" {:query-params {:Action ""
                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListUserPolicies"

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}}/?Action=&Version=#Action=ListUserPolicies"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListUserPolicies");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListUserPolicies"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListUserPolicies")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListUserPolicies"))
    .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}}/?Action=&Version=#Action=ListUserPolicies")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListUserPolicies")
  .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}}/?Action=&Version=#Action=ListUserPolicies');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListUserPolicies',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListUserPolicies';
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}}/?Action=&Version=#Action=ListUserPolicies',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListUserPolicies")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListUserPolicies',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListUserPolicies');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListUserPolicies',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListUserPolicies';
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}}/?Action=&Version=#Action=ListUserPolicies"]
                                                       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}}/?Action=&Version=#Action=ListUserPolicies" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListUserPolicies",
  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}}/?Action=&Version=#Action=ListUserPolicies');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListUserPolicies');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListUserPolicies');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListUserPolicies' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListUserPolicies' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListUserPolicies"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListUserPolicies"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListUserPolicies")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListUserPolicies";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListUserPolicies'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListUserPolicies'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListUserPolicies'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListUserPolicies")! 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 POST_ListUserTags
{{baseUrl}}/#Action=ListUserTags
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListUserTags");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListUserTags" {:query-params {:Action ""
                                                                                :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListUserTags"

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}}/?Action=&Version=#Action=ListUserTags"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListUserTags");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListUserTags"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListUserTags")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListUserTags"))
    .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}}/?Action=&Version=#Action=ListUserTags")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListUserTags")
  .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}}/?Action=&Version=#Action=ListUserTags');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListUserTags',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListUserTags';
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}}/?Action=&Version=#Action=ListUserTags',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListUserTags")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListUserTags',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListUserTags');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListUserTags',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListUserTags';
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}}/?Action=&Version=#Action=ListUserTags"]
                                                       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}}/?Action=&Version=#Action=ListUserTags" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListUserTags",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/?Action=&Version=#Action=ListUserTags');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListUserTags');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListUserTags');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListUserTags' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListUserTags' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/?Action=&Version=", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListUserTags"

querystring = {"Action":"","Version":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListUserTags"

queryString <- list(
  Action = "",
  Version = ""
)

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListUserTags")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListUserTags";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListUserTags'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListUserTags'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListUserTags'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListUserTags")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "IsTruncated": false,
  "Tags": [
    {
      "Key": "Dept",
      "Value": "12345"
    },
    {
      "Key": "Team",
      "Value": "Accounting"
    }
  ]
}
POST POST_ListUsers
{{baseUrl}}/#Action=ListUsers
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListUsers");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListUsers" {:query-params {:Action ""
                                                                             :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListUsers"

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}}/?Action=&Version=#Action=ListUsers"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListUsers");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListUsers"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListUsers")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListUsers"))
    .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}}/?Action=&Version=#Action=ListUsers")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListUsers")
  .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}}/?Action=&Version=#Action=ListUsers');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListUsers',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListUsers';
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}}/?Action=&Version=#Action=ListUsers',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListUsers")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListUsers',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListUsers');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListUsers',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListUsers';
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}}/?Action=&Version=#Action=ListUsers"]
                                                       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}}/?Action=&Version=#Action=ListUsers" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListUsers",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/?Action=&Version=#Action=ListUsers');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListUsers');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListUsers');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListUsers' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListUsers' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/?Action=&Version=", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListUsers"

querystring = {"Action":"","Version":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListUsers"

queryString <- list(
  Action = "",
  Version = ""
)

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListUsers")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListUsers";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListUsers'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListUsers'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListUsers'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListUsers")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "Users": [
    {
      "Arn": "arn:aws:iam::123456789012:user/division_abc/subdivision_xyz/engineering/Juan",
      "CreateDate": "2012-09-05T19:38:48Z",
      "PasswordLastUsed": "2016-09-08T21:47:36Z",
      "Path": "/division_abc/subdivision_xyz/engineering/",
      "UserId": "AID2MAB8DPLSRHEXAMPLE",
      "UserName": "Juan"
    },
    {
      "Arn": "arn:aws:iam::123456789012:user/division_abc/subdivision_xyz/engineering/Anika",
      "CreateDate": "2014-04-09T15:43:45Z",
      "PasswordLastUsed": "2016-09-24T16:18:07Z",
      "Path": "/division_abc/subdivision_xyz/engineering/",
      "UserId": "AIDIODR4TAW7CSEXAMPLE",
      "UserName": "Anika"
    }
  ]
}
POST POST_ListVirtualMFADevices
{{baseUrl}}/#Action=ListVirtualMFADevices
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListVirtualMFADevices" {:query-params {:Action ""
                                                                                         :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices"

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}}/?Action=&Version=#Action=ListVirtualMFADevices"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices"))
    .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}}/?Action=&Version=#Action=ListVirtualMFADevices")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices")
  .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}}/?Action=&Version=#Action=ListVirtualMFADevices');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListVirtualMFADevices',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices';
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}}/?Action=&Version=#Action=ListVirtualMFADevices',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ListVirtualMFADevices',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ListVirtualMFADevices');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListVirtualMFADevices',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices';
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}}/?Action=&Version=#Action=ListVirtualMFADevices"]
                                                       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}}/?Action=&Version=#Action=ListVirtualMFADevices" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListVirtualMFADevices');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListVirtualMFADevices');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/?Action=&Version=", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListVirtualMFADevices"

querystring = {"Action":"","Version":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListVirtualMFADevices"

queryString <- list(
  Action = "",
  Version = ""
)

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListVirtualMFADevices";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ListVirtualMFADevices'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListVirtualMFADevices")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "VirtualMFADevices": [
    {
      "SerialNumber": "arn:aws:iam::123456789012:mfa/ExampleMFADevice"
    },
    {
      "SerialNumber": "arn:aws:iam::123456789012:mfa/Juan"
    }
  ]
}
POST POST_PutGroupPolicy
{{baseUrl}}/#Action=PutGroupPolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=PutGroupPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=PutGroupPolicy" {:query-params {:Action ""
                                                                                  :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=PutGroupPolicy"

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}}/?Action=&Version=#Action=PutGroupPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=PutGroupPolicy");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=PutGroupPolicy"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=PutGroupPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=PutGroupPolicy"))
    .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}}/?Action=&Version=#Action=PutGroupPolicy")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=PutGroupPolicy")
  .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}}/?Action=&Version=#Action=PutGroupPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=PutGroupPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=PutGroupPolicy';
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}}/?Action=&Version=#Action=PutGroupPolicy',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=PutGroupPolicy")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=PutGroupPolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=PutGroupPolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=PutGroupPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=PutGroupPolicy';
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}}/?Action=&Version=#Action=PutGroupPolicy"]
                                                       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}}/?Action=&Version=#Action=PutGroupPolicy" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=PutGroupPolicy",
  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}}/?Action=&Version=#Action=PutGroupPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=PutGroupPolicy');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=PutGroupPolicy');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=PutGroupPolicy' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=PutGroupPolicy' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=PutGroupPolicy"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=PutGroupPolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=PutGroupPolicy")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=PutGroupPolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=PutGroupPolicy'
http POST '{{baseUrl}}/?Action=&Version=#Action=PutGroupPolicy'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=PutGroupPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=PutGroupPolicy")! 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 POST_PutRolePermissionsBoundary
{{baseUrl}}/#Action=PutRolePermissionsBoundary
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=PutRolePermissionsBoundary");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=PutRolePermissionsBoundary" {:query-params {:Action ""
                                                                                              :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=PutRolePermissionsBoundary"

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}}/?Action=&Version=#Action=PutRolePermissionsBoundary"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=PutRolePermissionsBoundary");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=PutRolePermissionsBoundary"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=PutRolePermissionsBoundary")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=PutRolePermissionsBoundary"))
    .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}}/?Action=&Version=#Action=PutRolePermissionsBoundary")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=PutRolePermissionsBoundary")
  .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}}/?Action=&Version=#Action=PutRolePermissionsBoundary');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=PutRolePermissionsBoundary',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=PutRolePermissionsBoundary';
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}}/?Action=&Version=#Action=PutRolePermissionsBoundary',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=PutRolePermissionsBoundary")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=PutRolePermissionsBoundary',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=PutRolePermissionsBoundary');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=PutRolePermissionsBoundary',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=PutRolePermissionsBoundary';
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}}/?Action=&Version=#Action=PutRolePermissionsBoundary"]
                                                       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}}/?Action=&Version=#Action=PutRolePermissionsBoundary" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=PutRolePermissionsBoundary",
  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}}/?Action=&Version=#Action=PutRolePermissionsBoundary');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=PutRolePermissionsBoundary');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=PutRolePermissionsBoundary');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=PutRolePermissionsBoundary' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=PutRolePermissionsBoundary' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=PutRolePermissionsBoundary"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=PutRolePermissionsBoundary"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=PutRolePermissionsBoundary")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=PutRolePermissionsBoundary";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=PutRolePermissionsBoundary'
http POST '{{baseUrl}}/?Action=&Version=#Action=PutRolePermissionsBoundary'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=PutRolePermissionsBoundary'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=PutRolePermissionsBoundary")! 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 POST_PutRolePolicy
{{baseUrl}}/#Action=PutRolePolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=PutRolePolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=PutRolePolicy" {:query-params {:Action ""
                                                                                 :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=PutRolePolicy"

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}}/?Action=&Version=#Action=PutRolePolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=PutRolePolicy");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=PutRolePolicy"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=PutRolePolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=PutRolePolicy"))
    .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}}/?Action=&Version=#Action=PutRolePolicy")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=PutRolePolicy")
  .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}}/?Action=&Version=#Action=PutRolePolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=PutRolePolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=PutRolePolicy';
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}}/?Action=&Version=#Action=PutRolePolicy',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=PutRolePolicy")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=PutRolePolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=PutRolePolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=PutRolePolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=PutRolePolicy';
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}}/?Action=&Version=#Action=PutRolePolicy"]
                                                       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}}/?Action=&Version=#Action=PutRolePolicy" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=PutRolePolicy",
  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}}/?Action=&Version=#Action=PutRolePolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=PutRolePolicy');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=PutRolePolicy');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=PutRolePolicy' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=PutRolePolicy' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=PutRolePolicy"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=PutRolePolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=PutRolePolicy")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=PutRolePolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=PutRolePolicy'
http POST '{{baseUrl}}/?Action=&Version=#Action=PutRolePolicy'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=PutRolePolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=PutRolePolicy")! 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 POST_PutUserPermissionsBoundary
{{baseUrl}}/#Action=PutUserPermissionsBoundary
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=PutUserPermissionsBoundary");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=PutUserPermissionsBoundary" {:query-params {:Action ""
                                                                                              :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=PutUserPermissionsBoundary"

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}}/?Action=&Version=#Action=PutUserPermissionsBoundary"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=PutUserPermissionsBoundary");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=PutUserPermissionsBoundary"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=PutUserPermissionsBoundary")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=PutUserPermissionsBoundary"))
    .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}}/?Action=&Version=#Action=PutUserPermissionsBoundary")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=PutUserPermissionsBoundary")
  .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}}/?Action=&Version=#Action=PutUserPermissionsBoundary');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=PutUserPermissionsBoundary',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=PutUserPermissionsBoundary';
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}}/?Action=&Version=#Action=PutUserPermissionsBoundary',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=PutUserPermissionsBoundary")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=PutUserPermissionsBoundary',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=PutUserPermissionsBoundary');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=PutUserPermissionsBoundary',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=PutUserPermissionsBoundary';
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}}/?Action=&Version=#Action=PutUserPermissionsBoundary"]
                                                       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}}/?Action=&Version=#Action=PutUserPermissionsBoundary" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=PutUserPermissionsBoundary",
  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}}/?Action=&Version=#Action=PutUserPermissionsBoundary');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=PutUserPermissionsBoundary');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=PutUserPermissionsBoundary');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=PutUserPermissionsBoundary' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=PutUserPermissionsBoundary' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=PutUserPermissionsBoundary"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=PutUserPermissionsBoundary"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=PutUserPermissionsBoundary")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=PutUserPermissionsBoundary";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=PutUserPermissionsBoundary'
http POST '{{baseUrl}}/?Action=&Version=#Action=PutUserPermissionsBoundary'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=PutUserPermissionsBoundary'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=PutUserPermissionsBoundary")! 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 POST_PutUserPolicy
{{baseUrl}}/#Action=PutUserPolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=PutUserPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=PutUserPolicy" {:query-params {:Action ""
                                                                                 :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=PutUserPolicy"

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}}/?Action=&Version=#Action=PutUserPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=PutUserPolicy");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=PutUserPolicy"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=PutUserPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=PutUserPolicy"))
    .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}}/?Action=&Version=#Action=PutUserPolicy")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=PutUserPolicy")
  .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}}/?Action=&Version=#Action=PutUserPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=PutUserPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=PutUserPolicy';
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}}/?Action=&Version=#Action=PutUserPolicy',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=PutUserPolicy")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=PutUserPolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=PutUserPolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=PutUserPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=PutUserPolicy';
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}}/?Action=&Version=#Action=PutUserPolicy"]
                                                       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}}/?Action=&Version=#Action=PutUserPolicy" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=PutUserPolicy",
  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}}/?Action=&Version=#Action=PutUserPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=PutUserPolicy');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=PutUserPolicy');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=PutUserPolicy' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=PutUserPolicy' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=PutUserPolicy"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=PutUserPolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=PutUserPolicy")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=PutUserPolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=PutUserPolicy'
http POST '{{baseUrl}}/?Action=&Version=#Action=PutUserPolicy'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=PutUserPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=PutUserPolicy")! 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 POST_RemoveClientIDFromOpenIDConnectProvider
{{baseUrl}}/#Action=RemoveClientIDFromOpenIDConnectProvider
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=RemoveClientIDFromOpenIDConnectProvider" {:query-params {:Action ""
                                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider"

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}}/?Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider"))
    .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}}/?Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider")
  .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}}/?Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=RemoveClientIDFromOpenIDConnectProvider',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider';
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}}/?Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=RemoveClientIDFromOpenIDConnectProvider',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=RemoveClientIDFromOpenIDConnectProvider');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=RemoveClientIDFromOpenIDConnectProvider',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider';
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}}/?Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider"]
                                                       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}}/?Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider",
  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}}/?Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=RemoveClientIDFromOpenIDConnectProvider');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=RemoveClientIDFromOpenIDConnectProvider');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=RemoveClientIDFromOpenIDConnectProvider"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=RemoveClientIDFromOpenIDConnectProvider"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=RemoveClientIDFromOpenIDConnectProvider";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider'
http POST '{{baseUrl}}/?Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=RemoveClientIDFromOpenIDConnectProvider")! 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 POST_RemoveRoleFromInstanceProfile
{{baseUrl}}/#Action=RemoveRoleFromInstanceProfile
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=RemoveRoleFromInstanceProfile");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=RemoveRoleFromInstanceProfile" {:query-params {:Action ""
                                                                                                 :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=RemoveRoleFromInstanceProfile"

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}}/?Action=&Version=#Action=RemoveRoleFromInstanceProfile"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=RemoveRoleFromInstanceProfile");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=RemoveRoleFromInstanceProfile"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=RemoveRoleFromInstanceProfile")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=RemoveRoleFromInstanceProfile"))
    .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}}/?Action=&Version=#Action=RemoveRoleFromInstanceProfile")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=RemoveRoleFromInstanceProfile")
  .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}}/?Action=&Version=#Action=RemoveRoleFromInstanceProfile');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=RemoveRoleFromInstanceProfile',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=RemoveRoleFromInstanceProfile';
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}}/?Action=&Version=#Action=RemoveRoleFromInstanceProfile',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=RemoveRoleFromInstanceProfile")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=RemoveRoleFromInstanceProfile',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=RemoveRoleFromInstanceProfile');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=RemoveRoleFromInstanceProfile',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=RemoveRoleFromInstanceProfile';
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}}/?Action=&Version=#Action=RemoveRoleFromInstanceProfile"]
                                                       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}}/?Action=&Version=#Action=RemoveRoleFromInstanceProfile" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=RemoveRoleFromInstanceProfile",
  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}}/?Action=&Version=#Action=RemoveRoleFromInstanceProfile');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=RemoveRoleFromInstanceProfile');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=RemoveRoleFromInstanceProfile');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=RemoveRoleFromInstanceProfile' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=RemoveRoleFromInstanceProfile' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=RemoveRoleFromInstanceProfile"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=RemoveRoleFromInstanceProfile"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=RemoveRoleFromInstanceProfile")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=RemoveRoleFromInstanceProfile";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=RemoveRoleFromInstanceProfile'
http POST '{{baseUrl}}/?Action=&Version=#Action=RemoveRoleFromInstanceProfile'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=RemoveRoleFromInstanceProfile'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=RemoveRoleFromInstanceProfile")! 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 POST_RemoveUserFromGroup
{{baseUrl}}/#Action=RemoveUserFromGroup
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=RemoveUserFromGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=RemoveUserFromGroup" {:query-params {:Action ""
                                                                                       :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=RemoveUserFromGroup"

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}}/?Action=&Version=#Action=RemoveUserFromGroup"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=RemoveUserFromGroup");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=RemoveUserFromGroup"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=RemoveUserFromGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=RemoveUserFromGroup"))
    .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}}/?Action=&Version=#Action=RemoveUserFromGroup")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=RemoveUserFromGroup")
  .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}}/?Action=&Version=#Action=RemoveUserFromGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=RemoveUserFromGroup',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=RemoveUserFromGroup';
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}}/?Action=&Version=#Action=RemoveUserFromGroup',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=RemoveUserFromGroup")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=RemoveUserFromGroup',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=RemoveUserFromGroup');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=RemoveUserFromGroup',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=RemoveUserFromGroup';
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}}/?Action=&Version=#Action=RemoveUserFromGroup"]
                                                       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}}/?Action=&Version=#Action=RemoveUserFromGroup" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=RemoveUserFromGroup",
  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}}/?Action=&Version=#Action=RemoveUserFromGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=RemoveUserFromGroup');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=RemoveUserFromGroup');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=RemoveUserFromGroup' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=RemoveUserFromGroup' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=RemoveUserFromGroup"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=RemoveUserFromGroup"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=RemoveUserFromGroup")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=RemoveUserFromGroup";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=RemoveUserFromGroup'
http POST '{{baseUrl}}/?Action=&Version=#Action=RemoveUserFromGroup'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=RemoveUserFromGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=RemoveUserFromGroup")! 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 POST_ResetServiceSpecificCredential
{{baseUrl}}/#Action=ResetServiceSpecificCredential
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ResetServiceSpecificCredential");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ResetServiceSpecificCredential" {:query-params {:Action ""
                                                                                                  :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ResetServiceSpecificCredential"

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}}/?Action=&Version=#Action=ResetServiceSpecificCredential"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ResetServiceSpecificCredential");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ResetServiceSpecificCredential"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ResetServiceSpecificCredential")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ResetServiceSpecificCredential"))
    .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}}/?Action=&Version=#Action=ResetServiceSpecificCredential")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ResetServiceSpecificCredential")
  .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}}/?Action=&Version=#Action=ResetServiceSpecificCredential');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ResetServiceSpecificCredential',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ResetServiceSpecificCredential';
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}}/?Action=&Version=#Action=ResetServiceSpecificCredential',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ResetServiceSpecificCredential")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ResetServiceSpecificCredential',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ResetServiceSpecificCredential');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ResetServiceSpecificCredential',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ResetServiceSpecificCredential';
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}}/?Action=&Version=#Action=ResetServiceSpecificCredential"]
                                                       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}}/?Action=&Version=#Action=ResetServiceSpecificCredential" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ResetServiceSpecificCredential",
  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}}/?Action=&Version=#Action=ResetServiceSpecificCredential');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ResetServiceSpecificCredential');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ResetServiceSpecificCredential');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ResetServiceSpecificCredential' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ResetServiceSpecificCredential' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ResetServiceSpecificCredential"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ResetServiceSpecificCredential"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ResetServiceSpecificCredential")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ResetServiceSpecificCredential";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ResetServiceSpecificCredential'
http POST '{{baseUrl}}/?Action=&Version=#Action=ResetServiceSpecificCredential'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ResetServiceSpecificCredential'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ResetServiceSpecificCredential")! 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 POST_ResyncMFADevice
{{baseUrl}}/#Action=ResyncMFADevice
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=ResyncMFADevice");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ResyncMFADevice" {:query-params {:Action ""
                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ResyncMFADevice"

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}}/?Action=&Version=#Action=ResyncMFADevice"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=ResyncMFADevice");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=ResyncMFADevice"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=ResyncMFADevice")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ResyncMFADevice"))
    .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}}/?Action=&Version=#Action=ResyncMFADevice")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ResyncMFADevice")
  .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}}/?Action=&Version=#Action=ResyncMFADevice');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ResyncMFADevice',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ResyncMFADevice';
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}}/?Action=&Version=#Action=ResyncMFADevice',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ResyncMFADevice")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=ResyncMFADevice',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=ResyncMFADevice');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ResyncMFADevice',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=ResyncMFADevice';
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}}/?Action=&Version=#Action=ResyncMFADevice"]
                                                       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}}/?Action=&Version=#Action=ResyncMFADevice" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ResyncMFADevice",
  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}}/?Action=&Version=#Action=ResyncMFADevice');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ResyncMFADevice');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ResyncMFADevice');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=ResyncMFADevice' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ResyncMFADevice' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ResyncMFADevice"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ResyncMFADevice"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=ResyncMFADevice")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ResyncMFADevice";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=ResyncMFADevice'
http POST '{{baseUrl}}/?Action=&Version=#Action=ResyncMFADevice'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ResyncMFADevice'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ResyncMFADevice")! 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 POST_SetDefaultPolicyVersion
{{baseUrl}}/#Action=SetDefaultPolicyVersion
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=SetDefaultPolicyVersion");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=SetDefaultPolicyVersion" {:query-params {:Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=SetDefaultPolicyVersion"

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}}/?Action=&Version=#Action=SetDefaultPolicyVersion"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=SetDefaultPolicyVersion");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=SetDefaultPolicyVersion"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=SetDefaultPolicyVersion")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=SetDefaultPolicyVersion"))
    .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}}/?Action=&Version=#Action=SetDefaultPolicyVersion")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=SetDefaultPolicyVersion")
  .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}}/?Action=&Version=#Action=SetDefaultPolicyVersion');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=SetDefaultPolicyVersion',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=SetDefaultPolicyVersion';
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}}/?Action=&Version=#Action=SetDefaultPolicyVersion',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=SetDefaultPolicyVersion")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=SetDefaultPolicyVersion',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=SetDefaultPolicyVersion');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=SetDefaultPolicyVersion',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=SetDefaultPolicyVersion';
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}}/?Action=&Version=#Action=SetDefaultPolicyVersion"]
                                                       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}}/?Action=&Version=#Action=SetDefaultPolicyVersion" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=SetDefaultPolicyVersion",
  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}}/?Action=&Version=#Action=SetDefaultPolicyVersion');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=SetDefaultPolicyVersion');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=SetDefaultPolicyVersion');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=SetDefaultPolicyVersion' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=SetDefaultPolicyVersion' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=SetDefaultPolicyVersion"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=SetDefaultPolicyVersion"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=SetDefaultPolicyVersion")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=SetDefaultPolicyVersion";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=SetDefaultPolicyVersion'
http POST '{{baseUrl}}/?Action=&Version=#Action=SetDefaultPolicyVersion'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=SetDefaultPolicyVersion'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=SetDefaultPolicyVersion")! 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 POST_SetSecurityTokenServicePreferences
{{baseUrl}}/#Action=SetSecurityTokenServicePreferences
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=SetSecurityTokenServicePreferences");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=SetSecurityTokenServicePreferences" {:query-params {:Action ""
                                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=SetSecurityTokenServicePreferences"

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}}/?Action=&Version=#Action=SetSecurityTokenServicePreferences"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=SetSecurityTokenServicePreferences");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=SetSecurityTokenServicePreferences"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=SetSecurityTokenServicePreferences")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=SetSecurityTokenServicePreferences"))
    .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}}/?Action=&Version=#Action=SetSecurityTokenServicePreferences")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=SetSecurityTokenServicePreferences")
  .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}}/?Action=&Version=#Action=SetSecurityTokenServicePreferences');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=SetSecurityTokenServicePreferences',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=SetSecurityTokenServicePreferences';
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}}/?Action=&Version=#Action=SetSecurityTokenServicePreferences',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=SetSecurityTokenServicePreferences")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=SetSecurityTokenServicePreferences',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=SetSecurityTokenServicePreferences');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=SetSecurityTokenServicePreferences',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=SetSecurityTokenServicePreferences';
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}}/?Action=&Version=#Action=SetSecurityTokenServicePreferences"]
                                                       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}}/?Action=&Version=#Action=SetSecurityTokenServicePreferences" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=SetSecurityTokenServicePreferences",
  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}}/?Action=&Version=#Action=SetSecurityTokenServicePreferences');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=SetSecurityTokenServicePreferences');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=SetSecurityTokenServicePreferences');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=SetSecurityTokenServicePreferences' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=SetSecurityTokenServicePreferences' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=SetSecurityTokenServicePreferences"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=SetSecurityTokenServicePreferences"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=SetSecurityTokenServicePreferences")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=SetSecurityTokenServicePreferences";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=SetSecurityTokenServicePreferences'
http POST '{{baseUrl}}/?Action=&Version=#Action=SetSecurityTokenServicePreferences'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=SetSecurityTokenServicePreferences'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=SetSecurityTokenServicePreferences")! 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 POST_SimulateCustomPolicy
{{baseUrl}}/#Action=SimulateCustomPolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=SimulateCustomPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=SimulateCustomPolicy" {:query-params {:Action ""
                                                                                        :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=SimulateCustomPolicy"

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}}/?Action=&Version=#Action=SimulateCustomPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=SimulateCustomPolicy");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=SimulateCustomPolicy"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=SimulateCustomPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=SimulateCustomPolicy"))
    .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}}/?Action=&Version=#Action=SimulateCustomPolicy")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=SimulateCustomPolicy")
  .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}}/?Action=&Version=#Action=SimulateCustomPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=SimulateCustomPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=SimulateCustomPolicy';
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}}/?Action=&Version=#Action=SimulateCustomPolicy',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=SimulateCustomPolicy")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=SimulateCustomPolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=SimulateCustomPolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=SimulateCustomPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=SimulateCustomPolicy';
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}}/?Action=&Version=#Action=SimulateCustomPolicy"]
                                                       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}}/?Action=&Version=#Action=SimulateCustomPolicy" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=SimulateCustomPolicy",
  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}}/?Action=&Version=#Action=SimulateCustomPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=SimulateCustomPolicy');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=SimulateCustomPolicy');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=SimulateCustomPolicy' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=SimulateCustomPolicy' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=SimulateCustomPolicy"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=SimulateCustomPolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=SimulateCustomPolicy")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=SimulateCustomPolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=SimulateCustomPolicy'
http POST '{{baseUrl}}/?Action=&Version=#Action=SimulateCustomPolicy'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=SimulateCustomPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=SimulateCustomPolicy")! 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 POST_SimulatePrincipalPolicy
{{baseUrl}}/#Action=SimulatePrincipalPolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=SimulatePrincipalPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=SimulatePrincipalPolicy" {:query-params {:Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=SimulatePrincipalPolicy"

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}}/?Action=&Version=#Action=SimulatePrincipalPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=SimulatePrincipalPolicy");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=SimulatePrincipalPolicy"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=SimulatePrincipalPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=SimulatePrincipalPolicy"))
    .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}}/?Action=&Version=#Action=SimulatePrincipalPolicy")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=SimulatePrincipalPolicy")
  .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}}/?Action=&Version=#Action=SimulatePrincipalPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=SimulatePrincipalPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=SimulatePrincipalPolicy';
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}}/?Action=&Version=#Action=SimulatePrincipalPolicy',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=SimulatePrincipalPolicy")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=SimulatePrincipalPolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=SimulatePrincipalPolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=SimulatePrincipalPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=SimulatePrincipalPolicy';
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}}/?Action=&Version=#Action=SimulatePrincipalPolicy"]
                                                       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}}/?Action=&Version=#Action=SimulatePrincipalPolicy" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=SimulatePrincipalPolicy",
  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}}/?Action=&Version=#Action=SimulatePrincipalPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=SimulatePrincipalPolicy');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=SimulatePrincipalPolicy');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=SimulatePrincipalPolicy' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=SimulatePrincipalPolicy' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=SimulatePrincipalPolicy"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=SimulatePrincipalPolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=SimulatePrincipalPolicy")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=SimulatePrincipalPolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=SimulatePrincipalPolicy'
http POST '{{baseUrl}}/?Action=&Version=#Action=SimulatePrincipalPolicy'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=SimulatePrincipalPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=SimulatePrincipalPolicy")! 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 POST_TagInstanceProfile
{{baseUrl}}/#Action=TagInstanceProfile
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=TagInstanceProfile");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=TagInstanceProfile" {:query-params {:Action ""
                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=TagInstanceProfile"

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}}/?Action=&Version=#Action=TagInstanceProfile"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=TagInstanceProfile");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=TagInstanceProfile"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=TagInstanceProfile")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=TagInstanceProfile"))
    .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}}/?Action=&Version=#Action=TagInstanceProfile")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=TagInstanceProfile")
  .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}}/?Action=&Version=#Action=TagInstanceProfile');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=TagInstanceProfile',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=TagInstanceProfile';
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}}/?Action=&Version=#Action=TagInstanceProfile',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=TagInstanceProfile")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=TagInstanceProfile',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=TagInstanceProfile');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=TagInstanceProfile',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=TagInstanceProfile';
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}}/?Action=&Version=#Action=TagInstanceProfile"]
                                                       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}}/?Action=&Version=#Action=TagInstanceProfile" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=TagInstanceProfile",
  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}}/?Action=&Version=#Action=TagInstanceProfile');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=TagInstanceProfile');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=TagInstanceProfile');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=TagInstanceProfile' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=TagInstanceProfile' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=TagInstanceProfile"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=TagInstanceProfile"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=TagInstanceProfile")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=TagInstanceProfile";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=TagInstanceProfile'
http POST '{{baseUrl}}/?Action=&Version=#Action=TagInstanceProfile'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=TagInstanceProfile'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=TagInstanceProfile")! 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 POST_TagMFADevice
{{baseUrl}}/#Action=TagMFADevice
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=TagMFADevice");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=TagMFADevice" {:query-params {:Action ""
                                                                                :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=TagMFADevice"

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}}/?Action=&Version=#Action=TagMFADevice"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=TagMFADevice");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=TagMFADevice"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=TagMFADevice")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=TagMFADevice"))
    .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}}/?Action=&Version=#Action=TagMFADevice")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=TagMFADevice")
  .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}}/?Action=&Version=#Action=TagMFADevice');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=TagMFADevice',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=TagMFADevice';
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}}/?Action=&Version=#Action=TagMFADevice',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=TagMFADevice")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=TagMFADevice',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=TagMFADevice');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=TagMFADevice',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=TagMFADevice';
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}}/?Action=&Version=#Action=TagMFADevice"]
                                                       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}}/?Action=&Version=#Action=TagMFADevice" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=TagMFADevice",
  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}}/?Action=&Version=#Action=TagMFADevice');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=TagMFADevice');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=TagMFADevice');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=TagMFADevice' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=TagMFADevice' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=TagMFADevice"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=TagMFADevice"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=TagMFADevice")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=TagMFADevice";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=TagMFADevice'
http POST '{{baseUrl}}/?Action=&Version=#Action=TagMFADevice'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=TagMFADevice'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=TagMFADevice")! 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 POST_TagOpenIDConnectProvider
{{baseUrl}}/#Action=TagOpenIDConnectProvider
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=TagOpenIDConnectProvider");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=TagOpenIDConnectProvider" {:query-params {:Action ""
                                                                                            :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=TagOpenIDConnectProvider"

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}}/?Action=&Version=#Action=TagOpenIDConnectProvider"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=TagOpenIDConnectProvider");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=TagOpenIDConnectProvider"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=TagOpenIDConnectProvider")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=TagOpenIDConnectProvider"))
    .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}}/?Action=&Version=#Action=TagOpenIDConnectProvider")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=TagOpenIDConnectProvider")
  .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}}/?Action=&Version=#Action=TagOpenIDConnectProvider');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=TagOpenIDConnectProvider',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=TagOpenIDConnectProvider';
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}}/?Action=&Version=#Action=TagOpenIDConnectProvider',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=TagOpenIDConnectProvider")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=TagOpenIDConnectProvider',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=TagOpenIDConnectProvider');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=TagOpenIDConnectProvider',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=TagOpenIDConnectProvider';
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}}/?Action=&Version=#Action=TagOpenIDConnectProvider"]
                                                       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}}/?Action=&Version=#Action=TagOpenIDConnectProvider" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=TagOpenIDConnectProvider",
  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}}/?Action=&Version=#Action=TagOpenIDConnectProvider');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=TagOpenIDConnectProvider');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=TagOpenIDConnectProvider');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=TagOpenIDConnectProvider' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=TagOpenIDConnectProvider' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=TagOpenIDConnectProvider"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=TagOpenIDConnectProvider"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=TagOpenIDConnectProvider")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=TagOpenIDConnectProvider";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=TagOpenIDConnectProvider'
http POST '{{baseUrl}}/?Action=&Version=#Action=TagOpenIDConnectProvider'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=TagOpenIDConnectProvider'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=TagOpenIDConnectProvider")! 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 POST_TagPolicy
{{baseUrl}}/#Action=TagPolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=TagPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=TagPolicy" {:query-params {:Action ""
                                                                             :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=TagPolicy"

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}}/?Action=&Version=#Action=TagPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=TagPolicy");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=TagPolicy"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=TagPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=TagPolicy"))
    .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}}/?Action=&Version=#Action=TagPolicy")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=TagPolicy")
  .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}}/?Action=&Version=#Action=TagPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=TagPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=TagPolicy';
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}}/?Action=&Version=#Action=TagPolicy',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=TagPolicy")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=TagPolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=TagPolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=TagPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=TagPolicy';
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}}/?Action=&Version=#Action=TagPolicy"]
                                                       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}}/?Action=&Version=#Action=TagPolicy" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=TagPolicy",
  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}}/?Action=&Version=#Action=TagPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=TagPolicy');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=TagPolicy');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=TagPolicy' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=TagPolicy' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=TagPolicy"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=TagPolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=TagPolicy")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=TagPolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=TagPolicy'
http POST '{{baseUrl}}/?Action=&Version=#Action=TagPolicy'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=TagPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=TagPolicy")! 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 POST_TagRole
{{baseUrl}}/#Action=TagRole
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=TagRole");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=TagRole" {:query-params {:Action ""
                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=TagRole"

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}}/?Action=&Version=#Action=TagRole"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=TagRole");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=TagRole"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=TagRole")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=TagRole"))
    .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}}/?Action=&Version=#Action=TagRole")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=TagRole")
  .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}}/?Action=&Version=#Action=TagRole');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=TagRole',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=TagRole';
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}}/?Action=&Version=#Action=TagRole',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=TagRole")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=TagRole',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=TagRole');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=TagRole',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=TagRole';
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}}/?Action=&Version=#Action=TagRole"]
                                                       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}}/?Action=&Version=#Action=TagRole" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=TagRole",
  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}}/?Action=&Version=#Action=TagRole');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=TagRole');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=TagRole');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=TagRole' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=TagRole' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=TagRole"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=TagRole"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=TagRole")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=TagRole";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=TagRole'
http POST '{{baseUrl}}/?Action=&Version=#Action=TagRole'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=TagRole'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=TagRole")! 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 POST_TagSAMLProvider
{{baseUrl}}/#Action=TagSAMLProvider
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=TagSAMLProvider");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=TagSAMLProvider" {:query-params {:Action ""
                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=TagSAMLProvider"

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}}/?Action=&Version=#Action=TagSAMLProvider"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=TagSAMLProvider");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=TagSAMLProvider"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=TagSAMLProvider")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=TagSAMLProvider"))
    .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}}/?Action=&Version=#Action=TagSAMLProvider")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=TagSAMLProvider")
  .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}}/?Action=&Version=#Action=TagSAMLProvider');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=TagSAMLProvider',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=TagSAMLProvider';
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}}/?Action=&Version=#Action=TagSAMLProvider',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=TagSAMLProvider")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=TagSAMLProvider',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=TagSAMLProvider');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=TagSAMLProvider',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=TagSAMLProvider';
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}}/?Action=&Version=#Action=TagSAMLProvider"]
                                                       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}}/?Action=&Version=#Action=TagSAMLProvider" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=TagSAMLProvider",
  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}}/?Action=&Version=#Action=TagSAMLProvider');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=TagSAMLProvider');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=TagSAMLProvider');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=TagSAMLProvider' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=TagSAMLProvider' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=TagSAMLProvider"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=TagSAMLProvider"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=TagSAMLProvider")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=TagSAMLProvider";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=TagSAMLProvider'
http POST '{{baseUrl}}/?Action=&Version=#Action=TagSAMLProvider'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=TagSAMLProvider'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=TagSAMLProvider")! 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 POST_TagServerCertificate
{{baseUrl}}/#Action=TagServerCertificate
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=TagServerCertificate");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=TagServerCertificate" {:query-params {:Action ""
                                                                                        :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=TagServerCertificate"

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}}/?Action=&Version=#Action=TagServerCertificate"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=TagServerCertificate");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=TagServerCertificate"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=TagServerCertificate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=TagServerCertificate"))
    .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}}/?Action=&Version=#Action=TagServerCertificate")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=TagServerCertificate")
  .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}}/?Action=&Version=#Action=TagServerCertificate');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=TagServerCertificate',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=TagServerCertificate';
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}}/?Action=&Version=#Action=TagServerCertificate',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=TagServerCertificate")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=TagServerCertificate',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=TagServerCertificate');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=TagServerCertificate',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=TagServerCertificate';
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}}/?Action=&Version=#Action=TagServerCertificate"]
                                                       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}}/?Action=&Version=#Action=TagServerCertificate" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=TagServerCertificate",
  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}}/?Action=&Version=#Action=TagServerCertificate');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=TagServerCertificate');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=TagServerCertificate');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=TagServerCertificate' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=TagServerCertificate' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=TagServerCertificate"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=TagServerCertificate"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=TagServerCertificate")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=TagServerCertificate";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=TagServerCertificate'
http POST '{{baseUrl}}/?Action=&Version=#Action=TagServerCertificate'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=TagServerCertificate'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=TagServerCertificate")! 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 POST_TagUser
{{baseUrl}}/#Action=TagUser
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=TagUser");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=TagUser" {:query-params {:Action ""
                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=TagUser"

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}}/?Action=&Version=#Action=TagUser"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=TagUser");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=TagUser"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=TagUser")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=TagUser"))
    .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}}/?Action=&Version=#Action=TagUser")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=TagUser")
  .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}}/?Action=&Version=#Action=TagUser');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=TagUser',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=TagUser';
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}}/?Action=&Version=#Action=TagUser',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=TagUser")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=TagUser',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=TagUser');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=TagUser',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=TagUser';
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}}/?Action=&Version=#Action=TagUser"]
                                                       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}}/?Action=&Version=#Action=TagUser" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=TagUser",
  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}}/?Action=&Version=#Action=TagUser');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=TagUser');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=TagUser');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=TagUser' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=TagUser' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=TagUser"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=TagUser"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=TagUser")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=TagUser";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=TagUser'
http POST '{{baseUrl}}/?Action=&Version=#Action=TagUser'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=TagUser'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=TagUser")! 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 POST_UntagInstanceProfile
{{baseUrl}}/#Action=UntagInstanceProfile
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=UntagInstanceProfile");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=UntagInstanceProfile" {:query-params {:Action ""
                                                                                        :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=UntagInstanceProfile"

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}}/?Action=&Version=#Action=UntagInstanceProfile"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=UntagInstanceProfile");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=UntagInstanceProfile"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=UntagInstanceProfile")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=UntagInstanceProfile"))
    .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}}/?Action=&Version=#Action=UntagInstanceProfile")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=UntagInstanceProfile")
  .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}}/?Action=&Version=#Action=UntagInstanceProfile');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UntagInstanceProfile',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=UntagInstanceProfile';
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}}/?Action=&Version=#Action=UntagInstanceProfile',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=UntagInstanceProfile")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=UntagInstanceProfile',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=UntagInstanceProfile');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UntagInstanceProfile',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=UntagInstanceProfile';
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}}/?Action=&Version=#Action=UntagInstanceProfile"]
                                                       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}}/?Action=&Version=#Action=UntagInstanceProfile" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=UntagInstanceProfile",
  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}}/?Action=&Version=#Action=UntagInstanceProfile');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UntagInstanceProfile');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UntagInstanceProfile');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=UntagInstanceProfile' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=UntagInstanceProfile' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UntagInstanceProfile"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UntagInstanceProfile"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=UntagInstanceProfile")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UntagInstanceProfile";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=UntagInstanceProfile'
http POST '{{baseUrl}}/?Action=&Version=#Action=UntagInstanceProfile'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=UntagInstanceProfile'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=UntagInstanceProfile")! 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 POST_UntagMFADevice
{{baseUrl}}/#Action=UntagMFADevice
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=UntagMFADevice");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=UntagMFADevice" {:query-params {:Action ""
                                                                                  :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=UntagMFADevice"

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}}/?Action=&Version=#Action=UntagMFADevice"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=UntagMFADevice");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=UntagMFADevice"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=UntagMFADevice")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=UntagMFADevice"))
    .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}}/?Action=&Version=#Action=UntagMFADevice")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=UntagMFADevice")
  .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}}/?Action=&Version=#Action=UntagMFADevice');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UntagMFADevice',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=UntagMFADevice';
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}}/?Action=&Version=#Action=UntagMFADevice',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=UntagMFADevice")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=UntagMFADevice',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=UntagMFADevice');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UntagMFADevice',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=UntagMFADevice';
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}}/?Action=&Version=#Action=UntagMFADevice"]
                                                       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}}/?Action=&Version=#Action=UntagMFADevice" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=UntagMFADevice",
  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}}/?Action=&Version=#Action=UntagMFADevice');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UntagMFADevice');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UntagMFADevice');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=UntagMFADevice' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=UntagMFADevice' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UntagMFADevice"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UntagMFADevice"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=UntagMFADevice")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UntagMFADevice";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=UntagMFADevice'
http POST '{{baseUrl}}/?Action=&Version=#Action=UntagMFADevice'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=UntagMFADevice'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=UntagMFADevice")! 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 POST_UntagOpenIDConnectProvider
{{baseUrl}}/#Action=UntagOpenIDConnectProvider
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=UntagOpenIDConnectProvider");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=UntagOpenIDConnectProvider" {:query-params {:Action ""
                                                                                              :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=UntagOpenIDConnectProvider"

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}}/?Action=&Version=#Action=UntagOpenIDConnectProvider"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=UntagOpenIDConnectProvider");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=UntagOpenIDConnectProvider"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=UntagOpenIDConnectProvider")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=UntagOpenIDConnectProvider"))
    .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}}/?Action=&Version=#Action=UntagOpenIDConnectProvider")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=UntagOpenIDConnectProvider")
  .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}}/?Action=&Version=#Action=UntagOpenIDConnectProvider');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UntagOpenIDConnectProvider',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=UntagOpenIDConnectProvider';
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}}/?Action=&Version=#Action=UntagOpenIDConnectProvider',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=UntagOpenIDConnectProvider")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=UntagOpenIDConnectProvider',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=UntagOpenIDConnectProvider');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UntagOpenIDConnectProvider',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=UntagOpenIDConnectProvider';
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}}/?Action=&Version=#Action=UntagOpenIDConnectProvider"]
                                                       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}}/?Action=&Version=#Action=UntagOpenIDConnectProvider" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=UntagOpenIDConnectProvider",
  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}}/?Action=&Version=#Action=UntagOpenIDConnectProvider');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UntagOpenIDConnectProvider');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UntagOpenIDConnectProvider');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=UntagOpenIDConnectProvider' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=UntagOpenIDConnectProvider' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UntagOpenIDConnectProvider"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UntagOpenIDConnectProvider"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=UntagOpenIDConnectProvider")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UntagOpenIDConnectProvider";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=UntagOpenIDConnectProvider'
http POST '{{baseUrl}}/?Action=&Version=#Action=UntagOpenIDConnectProvider'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=UntagOpenIDConnectProvider'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=UntagOpenIDConnectProvider")! 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 POST_UntagPolicy
{{baseUrl}}/#Action=UntagPolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=UntagPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=UntagPolicy" {:query-params {:Action ""
                                                                               :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=UntagPolicy"

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}}/?Action=&Version=#Action=UntagPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=UntagPolicy");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=UntagPolicy"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=UntagPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=UntagPolicy"))
    .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}}/?Action=&Version=#Action=UntagPolicy")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=UntagPolicy")
  .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}}/?Action=&Version=#Action=UntagPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UntagPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=UntagPolicy';
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}}/?Action=&Version=#Action=UntagPolicy',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=UntagPolicy")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=UntagPolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=UntagPolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UntagPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=UntagPolicy';
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}}/?Action=&Version=#Action=UntagPolicy"]
                                                       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}}/?Action=&Version=#Action=UntagPolicy" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=UntagPolicy",
  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}}/?Action=&Version=#Action=UntagPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UntagPolicy');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UntagPolicy');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=UntagPolicy' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=UntagPolicy' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UntagPolicy"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UntagPolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=UntagPolicy")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UntagPolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=UntagPolicy'
http POST '{{baseUrl}}/?Action=&Version=#Action=UntagPolicy'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=UntagPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=UntagPolicy")! 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 POST_UntagRole
{{baseUrl}}/#Action=UntagRole
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=UntagRole");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=UntagRole" {:query-params {:Action ""
                                                                             :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=UntagRole"

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}}/?Action=&Version=#Action=UntagRole"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=UntagRole");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=UntagRole"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=UntagRole")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=UntagRole"))
    .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}}/?Action=&Version=#Action=UntagRole")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=UntagRole")
  .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}}/?Action=&Version=#Action=UntagRole');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UntagRole',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=UntagRole';
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}}/?Action=&Version=#Action=UntagRole',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=UntagRole")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=UntagRole',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=UntagRole');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UntagRole',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=UntagRole';
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}}/?Action=&Version=#Action=UntagRole"]
                                                       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}}/?Action=&Version=#Action=UntagRole" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=UntagRole",
  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}}/?Action=&Version=#Action=UntagRole');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UntagRole');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UntagRole');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=UntagRole' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=UntagRole' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UntagRole"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UntagRole"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=UntagRole")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UntagRole";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=UntagRole'
http POST '{{baseUrl}}/?Action=&Version=#Action=UntagRole'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=UntagRole'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=UntagRole")! 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 POST_UntagSAMLProvider
{{baseUrl}}/#Action=UntagSAMLProvider
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=UntagSAMLProvider");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=UntagSAMLProvider" {:query-params {:Action ""
                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=UntagSAMLProvider"

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}}/?Action=&Version=#Action=UntagSAMLProvider"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=UntagSAMLProvider");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=UntagSAMLProvider"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=UntagSAMLProvider")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=UntagSAMLProvider"))
    .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}}/?Action=&Version=#Action=UntagSAMLProvider")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=UntagSAMLProvider")
  .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}}/?Action=&Version=#Action=UntagSAMLProvider');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UntagSAMLProvider',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=UntagSAMLProvider';
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}}/?Action=&Version=#Action=UntagSAMLProvider',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=UntagSAMLProvider")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=UntagSAMLProvider',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=UntagSAMLProvider');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UntagSAMLProvider',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=UntagSAMLProvider';
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}}/?Action=&Version=#Action=UntagSAMLProvider"]
                                                       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}}/?Action=&Version=#Action=UntagSAMLProvider" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=UntagSAMLProvider",
  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}}/?Action=&Version=#Action=UntagSAMLProvider');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UntagSAMLProvider');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UntagSAMLProvider');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=UntagSAMLProvider' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=UntagSAMLProvider' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UntagSAMLProvider"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UntagSAMLProvider"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=UntagSAMLProvider")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UntagSAMLProvider";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=UntagSAMLProvider'
http POST '{{baseUrl}}/?Action=&Version=#Action=UntagSAMLProvider'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=UntagSAMLProvider'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=UntagSAMLProvider")! 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 POST_UntagServerCertificate
{{baseUrl}}/#Action=UntagServerCertificate
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=UntagServerCertificate");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=UntagServerCertificate" {:query-params {:Action ""
                                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=UntagServerCertificate"

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}}/?Action=&Version=#Action=UntagServerCertificate"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=UntagServerCertificate");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=UntagServerCertificate"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=UntagServerCertificate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=UntagServerCertificate"))
    .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}}/?Action=&Version=#Action=UntagServerCertificate")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=UntagServerCertificate")
  .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}}/?Action=&Version=#Action=UntagServerCertificate');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UntagServerCertificate',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=UntagServerCertificate';
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}}/?Action=&Version=#Action=UntagServerCertificate',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=UntagServerCertificate")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=UntagServerCertificate',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=UntagServerCertificate');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UntagServerCertificate',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=UntagServerCertificate';
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}}/?Action=&Version=#Action=UntagServerCertificate"]
                                                       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}}/?Action=&Version=#Action=UntagServerCertificate" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=UntagServerCertificate",
  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}}/?Action=&Version=#Action=UntagServerCertificate');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UntagServerCertificate');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UntagServerCertificate');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=UntagServerCertificate' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=UntagServerCertificate' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UntagServerCertificate"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UntagServerCertificate"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=UntagServerCertificate")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UntagServerCertificate";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=UntagServerCertificate'
http POST '{{baseUrl}}/?Action=&Version=#Action=UntagServerCertificate'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=UntagServerCertificate'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=UntagServerCertificate")! 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 POST_UntagUser
{{baseUrl}}/#Action=UntagUser
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=UntagUser");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=UntagUser" {:query-params {:Action ""
                                                                             :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=UntagUser"

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}}/?Action=&Version=#Action=UntagUser"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=UntagUser");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=UntagUser"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=UntagUser")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=UntagUser"))
    .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}}/?Action=&Version=#Action=UntagUser")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=UntagUser")
  .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}}/?Action=&Version=#Action=UntagUser');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UntagUser',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=UntagUser';
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}}/?Action=&Version=#Action=UntagUser',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=UntagUser")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=UntagUser',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=UntagUser');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UntagUser',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=UntagUser';
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}}/?Action=&Version=#Action=UntagUser"]
                                                       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}}/?Action=&Version=#Action=UntagUser" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=UntagUser",
  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}}/?Action=&Version=#Action=UntagUser');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UntagUser');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UntagUser');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=UntagUser' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=UntagUser' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UntagUser"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UntagUser"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=UntagUser")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UntagUser";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=UntagUser'
http POST '{{baseUrl}}/?Action=&Version=#Action=UntagUser'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=UntagUser'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=UntagUser")! 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 POST_UpdateAccessKey
{{baseUrl}}/#Action=UpdateAccessKey
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=UpdateAccessKey");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=UpdateAccessKey" {:query-params {:Action ""
                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=UpdateAccessKey"

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}}/?Action=&Version=#Action=UpdateAccessKey"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=UpdateAccessKey");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=UpdateAccessKey"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=UpdateAccessKey")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=UpdateAccessKey"))
    .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}}/?Action=&Version=#Action=UpdateAccessKey")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=UpdateAccessKey")
  .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}}/?Action=&Version=#Action=UpdateAccessKey');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UpdateAccessKey',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateAccessKey';
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}}/?Action=&Version=#Action=UpdateAccessKey',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=UpdateAccessKey")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=UpdateAccessKey',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=UpdateAccessKey');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UpdateAccessKey',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateAccessKey';
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}}/?Action=&Version=#Action=UpdateAccessKey"]
                                                       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}}/?Action=&Version=#Action=UpdateAccessKey" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=UpdateAccessKey",
  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}}/?Action=&Version=#Action=UpdateAccessKey');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UpdateAccessKey');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UpdateAccessKey');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateAccessKey' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateAccessKey' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UpdateAccessKey"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UpdateAccessKey"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=UpdateAccessKey")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UpdateAccessKey";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=UpdateAccessKey'
http POST '{{baseUrl}}/?Action=&Version=#Action=UpdateAccessKey'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=UpdateAccessKey'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=UpdateAccessKey")! 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 POST_UpdateAccountPasswordPolicy
{{baseUrl}}/#Action=UpdateAccountPasswordPolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=UpdateAccountPasswordPolicy" {:query-params {:Action ""
                                                                                               :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy"

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}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy"))
    .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}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy")
  .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}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UpdateAccountPasswordPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy';
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}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=UpdateAccountPasswordPolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=UpdateAccountPasswordPolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UpdateAccountPasswordPolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy';
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}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy"]
                                                       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}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy",
  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}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UpdateAccountPasswordPolicy');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UpdateAccountPasswordPolicy');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UpdateAccountPasswordPolicy"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UpdateAccountPasswordPolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UpdateAccountPasswordPolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy'
http POST '{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=UpdateAccountPasswordPolicy")! 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 POST_UpdateAssumeRolePolicy
{{baseUrl}}/#Action=UpdateAssumeRolePolicy
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=UpdateAssumeRolePolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=UpdateAssumeRolePolicy" {:query-params {:Action ""
                                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=UpdateAssumeRolePolicy"

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}}/?Action=&Version=#Action=UpdateAssumeRolePolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=UpdateAssumeRolePolicy");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=UpdateAssumeRolePolicy"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=UpdateAssumeRolePolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=UpdateAssumeRolePolicy"))
    .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}}/?Action=&Version=#Action=UpdateAssumeRolePolicy")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=UpdateAssumeRolePolicy")
  .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}}/?Action=&Version=#Action=UpdateAssumeRolePolicy');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UpdateAssumeRolePolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateAssumeRolePolicy';
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}}/?Action=&Version=#Action=UpdateAssumeRolePolicy',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=UpdateAssumeRolePolicy")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=UpdateAssumeRolePolicy',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=UpdateAssumeRolePolicy');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UpdateAssumeRolePolicy',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateAssumeRolePolicy';
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}}/?Action=&Version=#Action=UpdateAssumeRolePolicy"]
                                                       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}}/?Action=&Version=#Action=UpdateAssumeRolePolicy" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=UpdateAssumeRolePolicy",
  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}}/?Action=&Version=#Action=UpdateAssumeRolePolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UpdateAssumeRolePolicy');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UpdateAssumeRolePolicy');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateAssumeRolePolicy' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateAssumeRolePolicy' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UpdateAssumeRolePolicy"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UpdateAssumeRolePolicy"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=UpdateAssumeRolePolicy")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UpdateAssumeRolePolicy";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=UpdateAssumeRolePolicy'
http POST '{{baseUrl}}/?Action=&Version=#Action=UpdateAssumeRolePolicy'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=UpdateAssumeRolePolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=UpdateAssumeRolePolicy")! 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 POST_UpdateGroup
{{baseUrl}}/#Action=UpdateGroup
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=UpdateGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=UpdateGroup" {:query-params {:Action ""
                                                                               :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=UpdateGroup"

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}}/?Action=&Version=#Action=UpdateGroup"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=UpdateGroup");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=UpdateGroup"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=UpdateGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=UpdateGroup"))
    .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}}/?Action=&Version=#Action=UpdateGroup")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=UpdateGroup")
  .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}}/?Action=&Version=#Action=UpdateGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UpdateGroup',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateGroup';
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}}/?Action=&Version=#Action=UpdateGroup',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=UpdateGroup")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=UpdateGroup',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=UpdateGroup');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UpdateGroup',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateGroup';
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}}/?Action=&Version=#Action=UpdateGroup"]
                                                       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}}/?Action=&Version=#Action=UpdateGroup" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=UpdateGroup",
  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}}/?Action=&Version=#Action=UpdateGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UpdateGroup');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UpdateGroup');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateGroup' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateGroup' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UpdateGroup"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UpdateGroup"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=UpdateGroup")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UpdateGroup";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=UpdateGroup'
http POST '{{baseUrl}}/?Action=&Version=#Action=UpdateGroup'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=UpdateGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=UpdateGroup")! 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 POST_UpdateLoginProfile
{{baseUrl}}/#Action=UpdateLoginProfile
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=UpdateLoginProfile");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=UpdateLoginProfile" {:query-params {:Action ""
                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=UpdateLoginProfile"

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}}/?Action=&Version=#Action=UpdateLoginProfile"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=UpdateLoginProfile");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=UpdateLoginProfile"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=UpdateLoginProfile")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=UpdateLoginProfile"))
    .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}}/?Action=&Version=#Action=UpdateLoginProfile")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=UpdateLoginProfile")
  .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}}/?Action=&Version=#Action=UpdateLoginProfile');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UpdateLoginProfile',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateLoginProfile';
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}}/?Action=&Version=#Action=UpdateLoginProfile',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=UpdateLoginProfile")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=UpdateLoginProfile',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=UpdateLoginProfile');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UpdateLoginProfile',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateLoginProfile';
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}}/?Action=&Version=#Action=UpdateLoginProfile"]
                                                       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}}/?Action=&Version=#Action=UpdateLoginProfile" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=UpdateLoginProfile",
  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}}/?Action=&Version=#Action=UpdateLoginProfile');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UpdateLoginProfile');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UpdateLoginProfile');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateLoginProfile' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateLoginProfile' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UpdateLoginProfile"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UpdateLoginProfile"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=UpdateLoginProfile")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UpdateLoginProfile";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=UpdateLoginProfile'
http POST '{{baseUrl}}/?Action=&Version=#Action=UpdateLoginProfile'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=UpdateLoginProfile'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=UpdateLoginProfile")! 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 POST_UpdateOpenIDConnectProviderThumbprint
{{baseUrl}}/#Action=UpdateOpenIDConnectProviderThumbprint
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=UpdateOpenIDConnectProviderThumbprint" {:query-params {:Action ""
                                                                                                         :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint"

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}}/?Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint"))
    .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}}/?Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint")
  .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}}/?Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UpdateOpenIDConnectProviderThumbprint',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint';
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}}/?Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=UpdateOpenIDConnectProviderThumbprint',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=UpdateOpenIDConnectProviderThumbprint');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UpdateOpenIDConnectProviderThumbprint',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint';
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}}/?Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint"]
                                                       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}}/?Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint",
  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}}/?Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UpdateOpenIDConnectProviderThumbprint');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UpdateOpenIDConnectProviderThumbprint');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UpdateOpenIDConnectProviderThumbprint"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UpdateOpenIDConnectProviderThumbprint"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UpdateOpenIDConnectProviderThumbprint";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint'
http POST '{{baseUrl}}/?Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=UpdateOpenIDConnectProviderThumbprint")! 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 POST_UpdateRole
{{baseUrl}}/#Action=UpdateRole
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=UpdateRole");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=UpdateRole" {:query-params {:Action ""
                                                                              :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=UpdateRole"

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}}/?Action=&Version=#Action=UpdateRole"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=UpdateRole");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=UpdateRole"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=UpdateRole")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=UpdateRole"))
    .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}}/?Action=&Version=#Action=UpdateRole")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=UpdateRole")
  .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}}/?Action=&Version=#Action=UpdateRole');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UpdateRole',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateRole';
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}}/?Action=&Version=#Action=UpdateRole',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=UpdateRole")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=UpdateRole',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=UpdateRole');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UpdateRole',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateRole';
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}}/?Action=&Version=#Action=UpdateRole"]
                                                       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}}/?Action=&Version=#Action=UpdateRole" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=UpdateRole",
  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}}/?Action=&Version=#Action=UpdateRole');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UpdateRole');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UpdateRole');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateRole' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateRole' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UpdateRole"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UpdateRole"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=UpdateRole")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UpdateRole";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=UpdateRole'
http POST '{{baseUrl}}/?Action=&Version=#Action=UpdateRole'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=UpdateRole'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=UpdateRole")! 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 POST_UpdateRoleDescription
{{baseUrl}}/#Action=UpdateRoleDescription
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=UpdateRoleDescription");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=UpdateRoleDescription" {:query-params {:Action ""
                                                                                         :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=UpdateRoleDescription"

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}}/?Action=&Version=#Action=UpdateRoleDescription"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=UpdateRoleDescription");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=UpdateRoleDescription"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=UpdateRoleDescription")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=UpdateRoleDescription"))
    .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}}/?Action=&Version=#Action=UpdateRoleDescription")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=UpdateRoleDescription")
  .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}}/?Action=&Version=#Action=UpdateRoleDescription');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UpdateRoleDescription',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateRoleDescription';
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}}/?Action=&Version=#Action=UpdateRoleDescription',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=UpdateRoleDescription")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=UpdateRoleDescription',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=UpdateRoleDescription');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UpdateRoleDescription',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateRoleDescription';
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}}/?Action=&Version=#Action=UpdateRoleDescription"]
                                                       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}}/?Action=&Version=#Action=UpdateRoleDescription" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=UpdateRoleDescription",
  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}}/?Action=&Version=#Action=UpdateRoleDescription');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UpdateRoleDescription');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UpdateRoleDescription');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateRoleDescription' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateRoleDescription' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UpdateRoleDescription"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UpdateRoleDescription"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=UpdateRoleDescription")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UpdateRoleDescription";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=UpdateRoleDescription'
http POST '{{baseUrl}}/?Action=&Version=#Action=UpdateRoleDescription'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=UpdateRoleDescription'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=UpdateRoleDescription")! 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 POST_UpdateSAMLProvider
{{baseUrl}}/#Action=UpdateSAMLProvider
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=UpdateSAMLProvider");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=UpdateSAMLProvider" {:query-params {:Action ""
                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=UpdateSAMLProvider"

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}}/?Action=&Version=#Action=UpdateSAMLProvider"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=UpdateSAMLProvider");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=UpdateSAMLProvider"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=UpdateSAMLProvider")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=UpdateSAMLProvider"))
    .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}}/?Action=&Version=#Action=UpdateSAMLProvider")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=UpdateSAMLProvider")
  .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}}/?Action=&Version=#Action=UpdateSAMLProvider');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UpdateSAMLProvider',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateSAMLProvider';
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}}/?Action=&Version=#Action=UpdateSAMLProvider',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=UpdateSAMLProvider")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=UpdateSAMLProvider',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=UpdateSAMLProvider');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UpdateSAMLProvider',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateSAMLProvider';
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}}/?Action=&Version=#Action=UpdateSAMLProvider"]
                                                       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}}/?Action=&Version=#Action=UpdateSAMLProvider" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=UpdateSAMLProvider",
  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}}/?Action=&Version=#Action=UpdateSAMLProvider');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UpdateSAMLProvider');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UpdateSAMLProvider');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateSAMLProvider' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateSAMLProvider' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UpdateSAMLProvider"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UpdateSAMLProvider"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=UpdateSAMLProvider")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UpdateSAMLProvider";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=UpdateSAMLProvider'
http POST '{{baseUrl}}/?Action=&Version=#Action=UpdateSAMLProvider'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=UpdateSAMLProvider'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=UpdateSAMLProvider")! 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 POST_UpdateSSHPublicKey
{{baseUrl}}/#Action=UpdateSSHPublicKey
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=UpdateSSHPublicKey");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=UpdateSSHPublicKey" {:query-params {:Action ""
                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=UpdateSSHPublicKey"

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}}/?Action=&Version=#Action=UpdateSSHPublicKey"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=UpdateSSHPublicKey");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=UpdateSSHPublicKey"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=UpdateSSHPublicKey")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=UpdateSSHPublicKey"))
    .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}}/?Action=&Version=#Action=UpdateSSHPublicKey")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=UpdateSSHPublicKey")
  .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}}/?Action=&Version=#Action=UpdateSSHPublicKey');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UpdateSSHPublicKey',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateSSHPublicKey';
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}}/?Action=&Version=#Action=UpdateSSHPublicKey',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=UpdateSSHPublicKey")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=UpdateSSHPublicKey',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=UpdateSSHPublicKey');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UpdateSSHPublicKey',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateSSHPublicKey';
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}}/?Action=&Version=#Action=UpdateSSHPublicKey"]
                                                       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}}/?Action=&Version=#Action=UpdateSSHPublicKey" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=UpdateSSHPublicKey",
  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}}/?Action=&Version=#Action=UpdateSSHPublicKey');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UpdateSSHPublicKey');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UpdateSSHPublicKey');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateSSHPublicKey' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateSSHPublicKey' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UpdateSSHPublicKey"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UpdateSSHPublicKey"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=UpdateSSHPublicKey")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UpdateSSHPublicKey";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=UpdateSSHPublicKey'
http POST '{{baseUrl}}/?Action=&Version=#Action=UpdateSSHPublicKey'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=UpdateSSHPublicKey'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=UpdateSSHPublicKey")! 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 POST_UpdateServerCertificate
{{baseUrl}}/#Action=UpdateServerCertificate
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=UpdateServerCertificate");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=UpdateServerCertificate" {:query-params {:Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=UpdateServerCertificate"

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}}/?Action=&Version=#Action=UpdateServerCertificate"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=UpdateServerCertificate");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=UpdateServerCertificate"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=UpdateServerCertificate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=UpdateServerCertificate"))
    .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}}/?Action=&Version=#Action=UpdateServerCertificate")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=UpdateServerCertificate")
  .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}}/?Action=&Version=#Action=UpdateServerCertificate');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UpdateServerCertificate',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateServerCertificate';
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}}/?Action=&Version=#Action=UpdateServerCertificate',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=UpdateServerCertificate")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=UpdateServerCertificate',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=UpdateServerCertificate');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UpdateServerCertificate',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateServerCertificate';
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}}/?Action=&Version=#Action=UpdateServerCertificate"]
                                                       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}}/?Action=&Version=#Action=UpdateServerCertificate" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=UpdateServerCertificate",
  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}}/?Action=&Version=#Action=UpdateServerCertificate');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UpdateServerCertificate');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UpdateServerCertificate');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateServerCertificate' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateServerCertificate' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UpdateServerCertificate"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UpdateServerCertificate"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=UpdateServerCertificate")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UpdateServerCertificate";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=UpdateServerCertificate'
http POST '{{baseUrl}}/?Action=&Version=#Action=UpdateServerCertificate'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=UpdateServerCertificate'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=UpdateServerCertificate")! 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 POST_UpdateServiceSpecificCredential
{{baseUrl}}/#Action=UpdateServiceSpecificCredential
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=UpdateServiceSpecificCredential");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=UpdateServiceSpecificCredential" {:query-params {:Action ""
                                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=UpdateServiceSpecificCredential"

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}}/?Action=&Version=#Action=UpdateServiceSpecificCredential"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=UpdateServiceSpecificCredential");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=UpdateServiceSpecificCredential"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=UpdateServiceSpecificCredential")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=UpdateServiceSpecificCredential"))
    .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}}/?Action=&Version=#Action=UpdateServiceSpecificCredential")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=UpdateServiceSpecificCredential")
  .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}}/?Action=&Version=#Action=UpdateServiceSpecificCredential');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UpdateServiceSpecificCredential',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateServiceSpecificCredential';
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}}/?Action=&Version=#Action=UpdateServiceSpecificCredential',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=UpdateServiceSpecificCredential")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=UpdateServiceSpecificCredential',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=UpdateServiceSpecificCredential');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UpdateServiceSpecificCredential',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateServiceSpecificCredential';
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}}/?Action=&Version=#Action=UpdateServiceSpecificCredential"]
                                                       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}}/?Action=&Version=#Action=UpdateServiceSpecificCredential" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=UpdateServiceSpecificCredential",
  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}}/?Action=&Version=#Action=UpdateServiceSpecificCredential');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UpdateServiceSpecificCredential');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UpdateServiceSpecificCredential');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateServiceSpecificCredential' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateServiceSpecificCredential' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UpdateServiceSpecificCredential"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UpdateServiceSpecificCredential"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=UpdateServiceSpecificCredential")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UpdateServiceSpecificCredential";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=UpdateServiceSpecificCredential'
http POST '{{baseUrl}}/?Action=&Version=#Action=UpdateServiceSpecificCredential'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=UpdateServiceSpecificCredential'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=UpdateServiceSpecificCredential")! 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 POST_UpdateSigningCertificate
{{baseUrl}}/#Action=UpdateSigningCertificate
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=UpdateSigningCertificate");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=UpdateSigningCertificate" {:query-params {:Action ""
                                                                                            :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=UpdateSigningCertificate"

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}}/?Action=&Version=#Action=UpdateSigningCertificate"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=UpdateSigningCertificate");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=UpdateSigningCertificate"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=UpdateSigningCertificate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=UpdateSigningCertificate"))
    .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}}/?Action=&Version=#Action=UpdateSigningCertificate")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=UpdateSigningCertificate")
  .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}}/?Action=&Version=#Action=UpdateSigningCertificate');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UpdateSigningCertificate',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateSigningCertificate';
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}}/?Action=&Version=#Action=UpdateSigningCertificate',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=UpdateSigningCertificate")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=UpdateSigningCertificate',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=UpdateSigningCertificate');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UpdateSigningCertificate',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateSigningCertificate';
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}}/?Action=&Version=#Action=UpdateSigningCertificate"]
                                                       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}}/?Action=&Version=#Action=UpdateSigningCertificate" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=UpdateSigningCertificate",
  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}}/?Action=&Version=#Action=UpdateSigningCertificate');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UpdateSigningCertificate');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UpdateSigningCertificate');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateSigningCertificate' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateSigningCertificate' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UpdateSigningCertificate"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UpdateSigningCertificate"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=UpdateSigningCertificate")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UpdateSigningCertificate";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=UpdateSigningCertificate'
http POST '{{baseUrl}}/?Action=&Version=#Action=UpdateSigningCertificate'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=UpdateSigningCertificate'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=UpdateSigningCertificate")! 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 POST_UpdateUser
{{baseUrl}}/#Action=UpdateUser
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=UpdateUser");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=UpdateUser" {:query-params {:Action ""
                                                                              :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=UpdateUser"

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}}/?Action=&Version=#Action=UpdateUser"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=UpdateUser");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=UpdateUser"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=UpdateUser")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=UpdateUser"))
    .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}}/?Action=&Version=#Action=UpdateUser")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=UpdateUser")
  .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}}/?Action=&Version=#Action=UpdateUser');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UpdateUser',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateUser';
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}}/?Action=&Version=#Action=UpdateUser',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=UpdateUser")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=UpdateUser',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=UpdateUser');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UpdateUser',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=UpdateUser';
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}}/?Action=&Version=#Action=UpdateUser"]
                                                       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}}/?Action=&Version=#Action=UpdateUser" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=UpdateUser",
  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}}/?Action=&Version=#Action=UpdateUser');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UpdateUser');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UpdateUser');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateUser' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=UpdateUser' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UpdateUser"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UpdateUser"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=UpdateUser")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UpdateUser";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=UpdateUser'
http POST '{{baseUrl}}/?Action=&Version=#Action=UpdateUser'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=UpdateUser'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=UpdateUser")! 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 POST_UploadSSHPublicKey
{{baseUrl}}/#Action=UploadSSHPublicKey
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=UploadSSHPublicKey");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=UploadSSHPublicKey" {:query-params {:Action ""
                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=UploadSSHPublicKey"

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}}/?Action=&Version=#Action=UploadSSHPublicKey"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=UploadSSHPublicKey");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=UploadSSHPublicKey"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=UploadSSHPublicKey")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=UploadSSHPublicKey"))
    .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}}/?Action=&Version=#Action=UploadSSHPublicKey")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=UploadSSHPublicKey")
  .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}}/?Action=&Version=#Action=UploadSSHPublicKey');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UploadSSHPublicKey',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=UploadSSHPublicKey';
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}}/?Action=&Version=#Action=UploadSSHPublicKey',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=UploadSSHPublicKey")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=UploadSSHPublicKey',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=UploadSSHPublicKey');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UploadSSHPublicKey',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=UploadSSHPublicKey';
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}}/?Action=&Version=#Action=UploadSSHPublicKey"]
                                                       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}}/?Action=&Version=#Action=UploadSSHPublicKey" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=UploadSSHPublicKey",
  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}}/?Action=&Version=#Action=UploadSSHPublicKey');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UploadSSHPublicKey');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UploadSSHPublicKey');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=UploadSSHPublicKey' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=UploadSSHPublicKey' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/?Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UploadSSHPublicKey"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UploadSSHPublicKey"

queryString <- list(
  Action = "",
  Version = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=UploadSSHPublicKey")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UploadSSHPublicKey";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=UploadSSHPublicKey'
http POST '{{baseUrl}}/?Action=&Version=#Action=UploadSSHPublicKey'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=UploadSSHPublicKey'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=UploadSSHPublicKey")! 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 POST_UploadServerCertificate
{{baseUrl}}/#Action=UploadServerCertificate
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=UploadServerCertificate");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=UploadServerCertificate" {:query-params {:Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=UploadServerCertificate"

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}}/?Action=&Version=#Action=UploadServerCertificate"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=UploadServerCertificate");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=UploadServerCertificate"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=UploadServerCertificate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=UploadServerCertificate"))
    .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}}/?Action=&Version=#Action=UploadServerCertificate")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=UploadServerCertificate")
  .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}}/?Action=&Version=#Action=UploadServerCertificate');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UploadServerCertificate',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=UploadServerCertificate';
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}}/?Action=&Version=#Action=UploadServerCertificate',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=UploadServerCertificate")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=UploadServerCertificate',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=UploadServerCertificate');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UploadServerCertificate',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=UploadServerCertificate';
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}}/?Action=&Version=#Action=UploadServerCertificate"]
                                                       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}}/?Action=&Version=#Action=UploadServerCertificate" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=UploadServerCertificate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/?Action=&Version=#Action=UploadServerCertificate');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UploadServerCertificate');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UploadServerCertificate');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=UploadServerCertificate' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=UploadServerCertificate' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/?Action=&Version=", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UploadServerCertificate"

querystring = {"Action":"","Version":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UploadServerCertificate"

queryString <- list(
  Action = "",
  Version = ""
)

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=UploadServerCertificate")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UploadServerCertificate";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=UploadServerCertificate'
http POST '{{baseUrl}}/?Action=&Version=#Action=UploadServerCertificate'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=UploadServerCertificate'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=UploadServerCertificate")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "ServerCertificateMetadata": {
    "Arn": "arn:aws:iam::123456789012:server-certificate/company/servercerts/ProdServerCert",
    "Expiration": "2012-05-08T01:02:03.004Z",
    "Path": "/company/servercerts/",
    "ServerCertificateId": "ASCA1111111111EXAMPLE",
    "ServerCertificateName": "ProdServerCert",
    "UploadDate": "2010-05-08T01:02:03.004Z"
  }
}
POST POST_UploadSigningCertificate
{{baseUrl}}/#Action=UploadSigningCertificate
QUERY PARAMS
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Action=&Version=#Action=UploadSigningCertificate");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=UploadSigningCertificate" {:query-params {:Action ""
                                                                                            :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=UploadSigningCertificate"

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}}/?Action=&Version=#Action=UploadSigningCertificate"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Action=&Version=#Action=UploadSigningCertificate");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Action=&Version=#Action=UploadSigningCertificate"

	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/?Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/?Action=&Version=#Action=UploadSigningCertificate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=UploadSigningCertificate"))
    .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}}/?Action=&Version=#Action=UploadSigningCertificate")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=UploadSigningCertificate")
  .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}}/?Action=&Version=#Action=UploadSigningCertificate');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UploadSigningCertificate',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=UploadSigningCertificate';
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}}/?Action=&Version=#Action=UploadSigningCertificate',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=UploadSigningCertificate")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Action=&Version=',
  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}}/#Action=UploadSigningCertificate',
  qs: {Action: '', Version: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#Action=UploadSigningCertificate');

req.query({
  Action: '',
  Version: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=UploadSigningCertificate',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Action=&Version=#Action=UploadSigningCertificate';
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}}/?Action=&Version=#Action=UploadSigningCertificate"]
                                                       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}}/?Action=&Version=#Action=UploadSigningCertificate" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=UploadSigningCertificate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/?Action=&Version=#Action=UploadSigningCertificate');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=UploadSigningCertificate');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=UploadSigningCertificate');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Action=&Version=#Action=UploadSigningCertificate' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=UploadSigningCertificate' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/?Action=&Version=", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=UploadSigningCertificate"

querystring = {"Action":"","Version":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=UploadSigningCertificate"

queryString <- list(
  Action = "",
  Version = ""
)

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Action=&Version=#Action=UploadSigningCertificate")

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/') do |req|
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=UploadSigningCertificate";

    let querystring = [
        ("Action", ""),
        ("Version", ""),
    ];

    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}}/?Action=&Version=#Action=UploadSigningCertificate'
http POST '{{baseUrl}}/?Action=&Version=#Action=UploadSigningCertificate'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=UploadSigningCertificate'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=UploadSigningCertificate")! 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()
RESPONSE HEADERS
Content-Type
text/xml
RESPONSE BODY xml
{
  "Certificate": {
    "CertificateBody": "-----BEGIN CERTIFICATE----------END CERTIFICATE-----",
    "CertificateId": "ID123456789012345EXAMPLE",
    "Status": "Active",
    "UploadDate": "2015-06-06T21:40:08.121Z",
    "UserName": "Bob"
  }
}