GET GET_AddRoleToDBCluster
{{baseUrl}}/#Action=AddRoleToDBCluster
QUERY PARAMS
DBClusterIdentifier
RoleArn
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

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

url = "{{baseUrl}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=AddRoleToDBCluster"

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}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=AddRoleToDBCluster"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=AddRoleToDBCluster");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=AddRoleToDBCluster"

	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/?DBClusterIdentifier=&RoleArn=&Action=&Version= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=AddRoleToDBCluster"))
    .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}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=AddRoleToDBCluster")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=AddRoleToDBCluster")
  .asString();
const 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}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=AddRoleToDBCluster');

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

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=AddRoleToDBCluster';
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}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=AddRoleToDBCluster',
  method: 'GET',
  headers: {}
};

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

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

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

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

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

  res.on('data', function (chunk) {
    chunks.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=AddRoleToDBCluster',
  qs: {DBClusterIdentifier: '', RoleArn: '', 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=AddRoleToDBCluster');

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

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=AddRoleToDBCluster',
  params: {DBClusterIdentifier: '', RoleArn: '', Action: '', Version: ''}
};

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

const url = '{{baseUrl}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=AddRoleToDBCluster';
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}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=AddRoleToDBCluster"]
                                                       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}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=AddRoleToDBCluster" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=AddRoleToDBCluster",
  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}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=AddRoleToDBCluster');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

url = URI("{{baseUrl}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=AddRoleToDBCluster")

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['DBClusterIdentifier'] = ''
  req.params['RoleArn'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("DBClusterIdentifier", ""),
        ("RoleArn", ""),
        ("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}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=AddRoleToDBCluster'
http GET '{{baseUrl}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=AddRoleToDBCluster'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=AddRoleToDBCluster'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=AddRoleToDBCluster")! 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_AddSourceIdentifierToSubscription
{{baseUrl}}/#Action=AddSourceIdentifierToSubscription
QUERY PARAMS
SubscriptionName
SourceIdentifier
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

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

url = "{{baseUrl}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=AddSourceIdentifierToSubscription"

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}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=AddSourceIdentifierToSubscription"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=AddSourceIdentifierToSubscription");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=AddSourceIdentifierToSubscription"

	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/?SubscriptionName=&SourceIdentifier=&Action=&Version= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=AddSourceIdentifierToSubscription"))
    .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}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=AddSourceIdentifierToSubscription")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=AddSourceIdentifierToSubscription")
  .asString();
const 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}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=AddSourceIdentifierToSubscription');

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

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=AddSourceIdentifierToSubscription';
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}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=AddSourceIdentifierToSubscription',
  method: 'GET',
  headers: {}
};

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

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

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

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

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

  res.on('data', function (chunk) {
    chunks.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=AddSourceIdentifierToSubscription',
  qs: {SubscriptionName: '', SourceIdentifier: '', 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=AddSourceIdentifierToSubscription');

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

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=AddSourceIdentifierToSubscription',
  params: {SubscriptionName: '', SourceIdentifier: '', Action: '', Version: ''}
};

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

const url = '{{baseUrl}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=AddSourceIdentifierToSubscription';
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}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=AddSourceIdentifierToSubscription"]
                                                       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}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=AddSourceIdentifierToSubscription" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=AddSourceIdentifierToSubscription",
  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}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=AddSourceIdentifierToSubscription');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

url = URI("{{baseUrl}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=AddSourceIdentifierToSubscription")

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['SubscriptionName'] = ''
  req.params['SourceIdentifier'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("SubscriptionName", ""),
        ("SourceIdentifier", ""),
        ("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}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=AddSourceIdentifierToSubscription'
http GET '{{baseUrl}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=AddSourceIdentifierToSubscription'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=AddSourceIdentifierToSubscription'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=AddSourceIdentifierToSubscription")! 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_AddTagsToResource
{{baseUrl}}/#Action=AddTagsToResource
QUERY PARAMS
ResourceName
Tags
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

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

url = "{{baseUrl}}/?ResourceName=&Tags=&Action=&Version=#Action=AddTagsToResource"

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}}/?ResourceName=&Tags=&Action=&Version=#Action=AddTagsToResource"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?ResourceName=&Tags=&Action=&Version=#Action=AddTagsToResource");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?ResourceName=&Tags=&Action=&Version=#Action=AddTagsToResource"

	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/?ResourceName=&Tags=&Action=&Version= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?ResourceName=&Tags=&Action=&Version=#Action=AddTagsToResource"))
    .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}}/?ResourceName=&Tags=&Action=&Version=#Action=AddTagsToResource")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?ResourceName=&Tags=&Action=&Version=#Action=AddTagsToResource")
  .asString();
const 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}}/?ResourceName=&Tags=&Action=&Version=#Action=AddTagsToResource');

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

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?ResourceName=&Tags=&Action=&Version=#Action=AddTagsToResource';
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}}/?ResourceName=&Tags=&Action=&Version=#Action=AddTagsToResource',
  method: 'GET',
  headers: {}
};

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

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

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

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?ResourceName=&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=AddTagsToResource',
  qs: {ResourceName: '', 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=AddTagsToResource');

req.query({
  ResourceName: '',
  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=AddTagsToResource',
  params: {ResourceName: '', 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}}/?ResourceName=&Tags=&Action=&Version=#Action=AddTagsToResource';
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}}/?ResourceName=&Tags=&Action=&Version=#Action=AddTagsToResource"]
                                                       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}}/?ResourceName=&Tags=&Action=&Version=#Action=AddTagsToResource" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?ResourceName=&Tags=&Action=&Version=#Action=AddTagsToResource",
  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}}/?ResourceName=&Tags=&Action=&Version=#Action=AddTagsToResource');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

queryString <- list(
  ResourceName = "",
  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}}/?ResourceName=&Tags=&Action=&Version=#Action=AddTagsToResource")

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['ResourceName'] = ''
  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=AddTagsToResource";

    let querystring = [
        ("ResourceName", ""),
        ("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}}/?ResourceName=&Tags=&Action=&Version=#Action=AddTagsToResource'
http GET '{{baseUrl}}/?ResourceName=&Tags=&Action=&Version=#Action=AddTagsToResource'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?ResourceName=&Tags=&Action=&Version=#Action=AddTagsToResource'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?ResourceName=&Tags=&Action=&Version=#Action=AddTagsToResource")! 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_ApplyPendingMaintenanceAction
{{baseUrl}}/#Action=ApplyPendingMaintenanceAction
QUERY PARAMS
ResourceIdentifier
ApplyAction
OptInType
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

(client/get "{{baseUrl}}/#Action=ApplyPendingMaintenanceAction" {:query-params {:ResourceIdentifier ""
                                                                                                :ApplyAction ""
                                                                                                :OptInType ""
                                                                                                :Action ""
                                                                                                :Version ""}})
require "http/client"

url = "{{baseUrl}}/?ResourceIdentifier=&ApplyAction=&OptInType=&Action=&Version=#Action=ApplyPendingMaintenanceAction"

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}}/?ResourceIdentifier=&ApplyAction=&OptInType=&Action=&Version=#Action=ApplyPendingMaintenanceAction"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?ResourceIdentifier=&ApplyAction=&OptInType=&Action=&Version=#Action=ApplyPendingMaintenanceAction");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?ResourceIdentifier=&ApplyAction=&OptInType=&Action=&Version=#Action=ApplyPendingMaintenanceAction"

	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/?ResourceIdentifier=&ApplyAction=&OptInType=&Action=&Version= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?ResourceIdentifier=&ApplyAction=&OptInType=&Action=&Version=#Action=ApplyPendingMaintenanceAction"))
    .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}}/?ResourceIdentifier=&ApplyAction=&OptInType=&Action=&Version=#Action=ApplyPendingMaintenanceAction")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?ResourceIdentifier=&ApplyAction=&OptInType=&Action=&Version=#Action=ApplyPendingMaintenanceAction")
  .asString();
const 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}}/?ResourceIdentifier=&ApplyAction=&OptInType=&Action=&Version=#Action=ApplyPendingMaintenanceAction');

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ApplyPendingMaintenanceAction',
  params: {
    ResourceIdentifier: '',
    ApplyAction: '',
    OptInType: '',
    Action: '',
    Version: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?ResourceIdentifier=&ApplyAction=&OptInType=&Action=&Version=#Action=ApplyPendingMaintenanceAction';
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}}/?ResourceIdentifier=&ApplyAction=&OptInType=&Action=&Version=#Action=ApplyPendingMaintenanceAction',
  method: 'GET',
  headers: {}
};

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

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

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

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

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

  res.on('data', function (chunk) {
    chunks.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=ApplyPendingMaintenanceAction',
  qs: {
    ResourceIdentifier: '',
    ApplyAction: '',
    OptInType: '',
    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=ApplyPendingMaintenanceAction');

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

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=ApplyPendingMaintenanceAction',
  params: {
    ResourceIdentifier: '',
    ApplyAction: '',
    OptInType: '',
    Action: '',
    Version: ''
  }
};

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

const url = '{{baseUrl}}/?ResourceIdentifier=&ApplyAction=&OptInType=&Action=&Version=#Action=ApplyPendingMaintenanceAction';
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}}/?ResourceIdentifier=&ApplyAction=&OptInType=&Action=&Version=#Action=ApplyPendingMaintenanceAction"]
                                                       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}}/?ResourceIdentifier=&ApplyAction=&OptInType=&Action=&Version=#Action=ApplyPendingMaintenanceAction" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?ResourceIdentifier=&ApplyAction=&OptInType=&Action=&Version=#Action=ApplyPendingMaintenanceAction",
  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}}/?ResourceIdentifier=&ApplyAction=&OptInType=&Action=&Version=#Action=ApplyPendingMaintenanceAction');

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

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

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

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

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

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

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

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

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

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

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

querystring = {"ResourceIdentifier":"","ApplyAction":"","OptInType":"","Action":"","Version":""}

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

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

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

queryString <- list(
  ResourceIdentifier = "",
  ApplyAction = "",
  OptInType = "",
  Action = "",
  Version = ""
)

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

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

url = URI("{{baseUrl}}/?ResourceIdentifier=&ApplyAction=&OptInType=&Action=&Version=#Action=ApplyPendingMaintenanceAction")

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['ResourceIdentifier'] = ''
  req.params['ApplyAction'] = ''
  req.params['OptInType'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("ResourceIdentifier", ""),
        ("ApplyAction", ""),
        ("OptInType", ""),
        ("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}}/?ResourceIdentifier=&ApplyAction=&OptInType=&Action=&Version=#Action=ApplyPendingMaintenanceAction'
http GET '{{baseUrl}}/?ResourceIdentifier=&ApplyAction=&OptInType=&Action=&Version=#Action=ApplyPendingMaintenanceAction'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?ResourceIdentifier=&ApplyAction=&OptInType=&Action=&Version=#Action=ApplyPendingMaintenanceAction'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?ResourceIdentifier=&ApplyAction=&OptInType=&Action=&Version=#Action=ApplyPendingMaintenanceAction")! 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_CopyDBClusterParameterGroup
{{baseUrl}}/#Action=CopyDBClusterParameterGroup
QUERY PARAMS
SourceDBClusterParameterGroupIdentifier
TargetDBClusterParameterGroupIdentifier
TargetDBClusterParameterGroupDescription
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

(client/get "{{baseUrl}}/#Action=CopyDBClusterParameterGroup" {:query-params {:SourceDBClusterParameterGroupIdentifier ""
                                                                                              :TargetDBClusterParameterGroupIdentifier ""
                                                                                              :TargetDBClusterParameterGroupDescription ""
                                                                                              :Action ""
                                                                                              :Version ""}})
require "http/client"

url = "{{baseUrl}}/?SourceDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupDescription=&Action=&Version=#Action=CopyDBClusterParameterGroup"

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}}/?SourceDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupDescription=&Action=&Version=#Action=CopyDBClusterParameterGroup"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?SourceDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupDescription=&Action=&Version=#Action=CopyDBClusterParameterGroup");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?SourceDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupDescription=&Action=&Version=#Action=CopyDBClusterParameterGroup"

	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/?SourceDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupDescription=&Action=&Version= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?SourceDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupDescription=&Action=&Version=#Action=CopyDBClusterParameterGroup"))
    .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}}/?SourceDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupDescription=&Action=&Version=#Action=CopyDBClusterParameterGroup")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?SourceDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupDescription=&Action=&Version=#Action=CopyDBClusterParameterGroup")
  .asString();
const 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}}/?SourceDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupDescription=&Action=&Version=#Action=CopyDBClusterParameterGroup');

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CopyDBClusterParameterGroup',
  params: {
    SourceDBClusterParameterGroupIdentifier: '',
    TargetDBClusterParameterGroupIdentifier: '',
    TargetDBClusterParameterGroupDescription: '',
    Action: '',
    Version: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?SourceDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupDescription=&Action=&Version=#Action=CopyDBClusterParameterGroup';
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}}/?SourceDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupDescription=&Action=&Version=#Action=CopyDBClusterParameterGroup',
  method: 'GET',
  headers: {}
};

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

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

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

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

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

  res.on('data', function (chunk) {
    chunks.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=CopyDBClusterParameterGroup',
  qs: {
    SourceDBClusterParameterGroupIdentifier: '',
    TargetDBClusterParameterGroupIdentifier: '',
    TargetDBClusterParameterGroupDescription: '',
    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=CopyDBClusterParameterGroup');

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

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=CopyDBClusterParameterGroup',
  params: {
    SourceDBClusterParameterGroupIdentifier: '',
    TargetDBClusterParameterGroupIdentifier: '',
    TargetDBClusterParameterGroupDescription: '',
    Action: '',
    Version: ''
  }
};

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

const url = '{{baseUrl}}/?SourceDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupDescription=&Action=&Version=#Action=CopyDBClusterParameterGroup';
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}}/?SourceDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupDescription=&Action=&Version=#Action=CopyDBClusterParameterGroup"]
                                                       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}}/?SourceDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupDescription=&Action=&Version=#Action=CopyDBClusterParameterGroup" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?SourceDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupDescription=&Action=&Version=#Action=CopyDBClusterParameterGroup",
  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}}/?SourceDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupDescription=&Action=&Version=#Action=CopyDBClusterParameterGroup');

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

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

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

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

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

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

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

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

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

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

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

querystring = {"SourceDBClusterParameterGroupIdentifier":"","TargetDBClusterParameterGroupIdentifier":"","TargetDBClusterParameterGroupDescription":"","Action":"","Version":""}

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

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

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

queryString <- list(
  SourceDBClusterParameterGroupIdentifier = "",
  TargetDBClusterParameterGroupIdentifier = "",
  TargetDBClusterParameterGroupDescription = "",
  Action = "",
  Version = ""
)

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

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

url = URI("{{baseUrl}}/?SourceDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupDescription=&Action=&Version=#Action=CopyDBClusterParameterGroup")

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['SourceDBClusterParameterGroupIdentifier'] = ''
  req.params['TargetDBClusterParameterGroupIdentifier'] = ''
  req.params['TargetDBClusterParameterGroupDescription'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("SourceDBClusterParameterGroupIdentifier", ""),
        ("TargetDBClusterParameterGroupIdentifier", ""),
        ("TargetDBClusterParameterGroupDescription", ""),
        ("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}}/?SourceDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupDescription=&Action=&Version=#Action=CopyDBClusterParameterGroup'
http GET '{{baseUrl}}/?SourceDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupDescription=&Action=&Version=#Action=CopyDBClusterParameterGroup'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?SourceDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupDescription=&Action=&Version=#Action=CopyDBClusterParameterGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?SourceDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupIdentifier=&TargetDBClusterParameterGroupDescription=&Action=&Version=#Action=CopyDBClusterParameterGroup")! 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_CopyDBClusterSnapshot
{{baseUrl}}/#Action=CopyDBClusterSnapshot
QUERY PARAMS
SourceDBClusterSnapshotIdentifier
TargetDBClusterSnapshotIdentifier
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

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

url = "{{baseUrl}}/?SourceDBClusterSnapshotIdentifier=&TargetDBClusterSnapshotIdentifier=&Action=&Version=#Action=CopyDBClusterSnapshot"

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}}/?SourceDBClusterSnapshotIdentifier=&TargetDBClusterSnapshotIdentifier=&Action=&Version=#Action=CopyDBClusterSnapshot"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?SourceDBClusterSnapshotIdentifier=&TargetDBClusterSnapshotIdentifier=&Action=&Version=#Action=CopyDBClusterSnapshot");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?SourceDBClusterSnapshotIdentifier=&TargetDBClusterSnapshotIdentifier=&Action=&Version=#Action=CopyDBClusterSnapshot"

	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/?SourceDBClusterSnapshotIdentifier=&TargetDBClusterSnapshotIdentifier=&Action=&Version= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?SourceDBClusterSnapshotIdentifier=&TargetDBClusterSnapshotIdentifier=&Action=&Version=#Action=CopyDBClusterSnapshot"))
    .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}}/?SourceDBClusterSnapshotIdentifier=&TargetDBClusterSnapshotIdentifier=&Action=&Version=#Action=CopyDBClusterSnapshot")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?SourceDBClusterSnapshotIdentifier=&TargetDBClusterSnapshotIdentifier=&Action=&Version=#Action=CopyDBClusterSnapshot")
  .asString();
const 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}}/?SourceDBClusterSnapshotIdentifier=&TargetDBClusterSnapshotIdentifier=&Action=&Version=#Action=CopyDBClusterSnapshot');

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

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?SourceDBClusterSnapshotIdentifier=&TargetDBClusterSnapshotIdentifier=&Action=&Version=#Action=CopyDBClusterSnapshot';
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}}/?SourceDBClusterSnapshotIdentifier=&TargetDBClusterSnapshotIdentifier=&Action=&Version=#Action=CopyDBClusterSnapshot',
  method: 'GET',
  headers: {}
};

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

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

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

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

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

  res.on('data', function (chunk) {
    chunks.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=CopyDBClusterSnapshot',
  qs: {
    SourceDBClusterSnapshotIdentifier: '',
    TargetDBClusterSnapshotIdentifier: '',
    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=CopyDBClusterSnapshot');

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

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=CopyDBClusterSnapshot',
  params: {
    SourceDBClusterSnapshotIdentifier: '',
    TargetDBClusterSnapshotIdentifier: '',
    Action: '',
    Version: ''
  }
};

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

const url = '{{baseUrl}}/?SourceDBClusterSnapshotIdentifier=&TargetDBClusterSnapshotIdentifier=&Action=&Version=#Action=CopyDBClusterSnapshot';
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}}/?SourceDBClusterSnapshotIdentifier=&TargetDBClusterSnapshotIdentifier=&Action=&Version=#Action=CopyDBClusterSnapshot"]
                                                       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}}/?SourceDBClusterSnapshotIdentifier=&TargetDBClusterSnapshotIdentifier=&Action=&Version=#Action=CopyDBClusterSnapshot" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?SourceDBClusterSnapshotIdentifier=&TargetDBClusterSnapshotIdentifier=&Action=&Version=#Action=CopyDBClusterSnapshot",
  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}}/?SourceDBClusterSnapshotIdentifier=&TargetDBClusterSnapshotIdentifier=&Action=&Version=#Action=CopyDBClusterSnapshot');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

url = URI("{{baseUrl}}/?SourceDBClusterSnapshotIdentifier=&TargetDBClusterSnapshotIdentifier=&Action=&Version=#Action=CopyDBClusterSnapshot")

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['SourceDBClusterSnapshotIdentifier'] = ''
  req.params['TargetDBClusterSnapshotIdentifier'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("SourceDBClusterSnapshotIdentifier", ""),
        ("TargetDBClusterSnapshotIdentifier", ""),
        ("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}}/?SourceDBClusterSnapshotIdentifier=&TargetDBClusterSnapshotIdentifier=&Action=&Version=#Action=CopyDBClusterSnapshot'
http GET '{{baseUrl}}/?SourceDBClusterSnapshotIdentifier=&TargetDBClusterSnapshotIdentifier=&Action=&Version=#Action=CopyDBClusterSnapshot'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?SourceDBClusterSnapshotIdentifier=&TargetDBClusterSnapshotIdentifier=&Action=&Version=#Action=CopyDBClusterSnapshot'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?SourceDBClusterSnapshotIdentifier=&TargetDBClusterSnapshotIdentifier=&Action=&Version=#Action=CopyDBClusterSnapshot")! 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_CopyDBParameterGroup
{{baseUrl}}/#Action=CopyDBParameterGroup
QUERY PARAMS
SourceDBParameterGroupIdentifier
TargetDBParameterGroupIdentifier
TargetDBParameterGroupDescription
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

(client/get "{{baseUrl}}/#Action=CopyDBParameterGroup" {:query-params {:SourceDBParameterGroupIdentifier ""
                                                                                       :TargetDBParameterGroupIdentifier ""
                                                                                       :TargetDBParameterGroupDescription ""
                                                                                       :Action ""
                                                                                       :Version ""}})
require "http/client"

url = "{{baseUrl}}/?SourceDBParameterGroupIdentifier=&TargetDBParameterGroupIdentifier=&TargetDBParameterGroupDescription=&Action=&Version=#Action=CopyDBParameterGroup"

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}}/?SourceDBParameterGroupIdentifier=&TargetDBParameterGroupIdentifier=&TargetDBParameterGroupDescription=&Action=&Version=#Action=CopyDBParameterGroup"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?SourceDBParameterGroupIdentifier=&TargetDBParameterGroupIdentifier=&TargetDBParameterGroupDescription=&Action=&Version=#Action=CopyDBParameterGroup");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?SourceDBParameterGroupIdentifier=&TargetDBParameterGroupIdentifier=&TargetDBParameterGroupDescription=&Action=&Version=#Action=CopyDBParameterGroup"

	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/?SourceDBParameterGroupIdentifier=&TargetDBParameterGroupIdentifier=&TargetDBParameterGroupDescription=&Action=&Version= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?SourceDBParameterGroupIdentifier=&TargetDBParameterGroupIdentifier=&TargetDBParameterGroupDescription=&Action=&Version=#Action=CopyDBParameterGroup"))
    .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}}/?SourceDBParameterGroupIdentifier=&TargetDBParameterGroupIdentifier=&TargetDBParameterGroupDescription=&Action=&Version=#Action=CopyDBParameterGroup")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?SourceDBParameterGroupIdentifier=&TargetDBParameterGroupIdentifier=&TargetDBParameterGroupDescription=&Action=&Version=#Action=CopyDBParameterGroup")
  .asString();
const 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}}/?SourceDBParameterGroupIdentifier=&TargetDBParameterGroupIdentifier=&TargetDBParameterGroupDescription=&Action=&Version=#Action=CopyDBParameterGroup');

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CopyDBParameterGroup',
  params: {
    SourceDBParameterGroupIdentifier: '',
    TargetDBParameterGroupIdentifier: '',
    TargetDBParameterGroupDescription: '',
    Action: '',
    Version: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?SourceDBParameterGroupIdentifier=&TargetDBParameterGroupIdentifier=&TargetDBParameterGroupDescription=&Action=&Version=#Action=CopyDBParameterGroup';
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}}/?SourceDBParameterGroupIdentifier=&TargetDBParameterGroupIdentifier=&TargetDBParameterGroupDescription=&Action=&Version=#Action=CopyDBParameterGroup',
  method: 'GET',
  headers: {}
};

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

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

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

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

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

  res.on('data', function (chunk) {
    chunks.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=CopyDBParameterGroup',
  qs: {
    SourceDBParameterGroupIdentifier: '',
    TargetDBParameterGroupIdentifier: '',
    TargetDBParameterGroupDescription: '',
    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=CopyDBParameterGroup');

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

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=CopyDBParameterGroup',
  params: {
    SourceDBParameterGroupIdentifier: '',
    TargetDBParameterGroupIdentifier: '',
    TargetDBParameterGroupDescription: '',
    Action: '',
    Version: ''
  }
};

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

const url = '{{baseUrl}}/?SourceDBParameterGroupIdentifier=&TargetDBParameterGroupIdentifier=&TargetDBParameterGroupDescription=&Action=&Version=#Action=CopyDBParameterGroup';
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}}/?SourceDBParameterGroupIdentifier=&TargetDBParameterGroupIdentifier=&TargetDBParameterGroupDescription=&Action=&Version=#Action=CopyDBParameterGroup"]
                                                       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}}/?SourceDBParameterGroupIdentifier=&TargetDBParameterGroupIdentifier=&TargetDBParameterGroupDescription=&Action=&Version=#Action=CopyDBParameterGroup" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?SourceDBParameterGroupIdentifier=&TargetDBParameterGroupIdentifier=&TargetDBParameterGroupDescription=&Action=&Version=#Action=CopyDBParameterGroup",
  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}}/?SourceDBParameterGroupIdentifier=&TargetDBParameterGroupIdentifier=&TargetDBParameterGroupDescription=&Action=&Version=#Action=CopyDBParameterGroup');

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

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

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

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

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

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

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

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

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

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

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

querystring = {"SourceDBParameterGroupIdentifier":"","TargetDBParameterGroupIdentifier":"","TargetDBParameterGroupDescription":"","Action":"","Version":""}

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

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

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

queryString <- list(
  SourceDBParameterGroupIdentifier = "",
  TargetDBParameterGroupIdentifier = "",
  TargetDBParameterGroupDescription = "",
  Action = "",
  Version = ""
)

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

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

url = URI("{{baseUrl}}/?SourceDBParameterGroupIdentifier=&TargetDBParameterGroupIdentifier=&TargetDBParameterGroupDescription=&Action=&Version=#Action=CopyDBParameterGroup")

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['SourceDBParameterGroupIdentifier'] = ''
  req.params['TargetDBParameterGroupIdentifier'] = ''
  req.params['TargetDBParameterGroupDescription'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("SourceDBParameterGroupIdentifier", ""),
        ("TargetDBParameterGroupIdentifier", ""),
        ("TargetDBParameterGroupDescription", ""),
        ("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}}/?SourceDBParameterGroupIdentifier=&TargetDBParameterGroupIdentifier=&TargetDBParameterGroupDescription=&Action=&Version=#Action=CopyDBParameterGroup'
http GET '{{baseUrl}}/?SourceDBParameterGroupIdentifier=&TargetDBParameterGroupIdentifier=&TargetDBParameterGroupDescription=&Action=&Version=#Action=CopyDBParameterGroup'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?SourceDBParameterGroupIdentifier=&TargetDBParameterGroupIdentifier=&TargetDBParameterGroupDescription=&Action=&Version=#Action=CopyDBParameterGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?SourceDBParameterGroupIdentifier=&TargetDBParameterGroupIdentifier=&TargetDBParameterGroupDescription=&Action=&Version=#Action=CopyDBParameterGroup")! 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_CreateDBCluster
{{baseUrl}}/#Action=CreateDBCluster
QUERY PARAMS
DBClusterIdentifier
Engine
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

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

url = "{{baseUrl}}/?DBClusterIdentifier=&Engine=&Action=&Version=#Action=CreateDBCluster"

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}}/?DBClusterIdentifier=&Engine=&Action=&Version=#Action=CreateDBCluster"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBClusterIdentifier=&Engine=&Action=&Version=#Action=CreateDBCluster");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?DBClusterIdentifier=&Engine=&Action=&Version=#Action=CreateDBCluster"

	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/?DBClusterIdentifier=&Engine=&Action=&Version= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBClusterIdentifier=&Engine=&Action=&Version=#Action=CreateDBCluster"))
    .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}}/?DBClusterIdentifier=&Engine=&Action=&Version=#Action=CreateDBCluster")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBClusterIdentifier=&Engine=&Action=&Version=#Action=CreateDBCluster")
  .asString();
const 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}}/?DBClusterIdentifier=&Engine=&Action=&Version=#Action=CreateDBCluster');

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

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBClusterIdentifier=&Engine=&Action=&Version=#Action=CreateDBCluster';
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}}/?DBClusterIdentifier=&Engine=&Action=&Version=#Action=CreateDBCluster',
  method: 'GET',
  headers: {}
};

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

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

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

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

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

  res.on('data', function (chunk) {
    chunks.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=CreateDBCluster',
  qs: {DBClusterIdentifier: '', Engine: '', 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=CreateDBCluster');

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

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=CreateDBCluster',
  params: {DBClusterIdentifier: '', Engine: '', Action: '', Version: ''}
};

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

const url = '{{baseUrl}}/?DBClusterIdentifier=&Engine=&Action=&Version=#Action=CreateDBCluster';
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}}/?DBClusterIdentifier=&Engine=&Action=&Version=#Action=CreateDBCluster"]
                                                       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}}/?DBClusterIdentifier=&Engine=&Action=&Version=#Action=CreateDBCluster" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBClusterIdentifier=&Engine=&Action=&Version=#Action=CreateDBCluster",
  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}}/?DBClusterIdentifier=&Engine=&Action=&Version=#Action=CreateDBCluster');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

url = URI("{{baseUrl}}/?DBClusterIdentifier=&Engine=&Action=&Version=#Action=CreateDBCluster")

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['DBClusterIdentifier'] = ''
  req.params['Engine'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("DBClusterIdentifier", ""),
        ("Engine", ""),
        ("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}}/?DBClusterIdentifier=&Engine=&Action=&Version=#Action=CreateDBCluster'
http GET '{{baseUrl}}/?DBClusterIdentifier=&Engine=&Action=&Version=#Action=CreateDBCluster'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBClusterIdentifier=&Engine=&Action=&Version=#Action=CreateDBCluster'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBClusterIdentifier=&Engine=&Action=&Version=#Action=CreateDBCluster")! 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_CreateDBClusterEndpoint
{{baseUrl}}/#Action=CreateDBClusterEndpoint
QUERY PARAMS
DBClusterIdentifier
DBClusterEndpointIdentifier
EndpointType
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

(client/get "{{baseUrl}}/#Action=CreateDBClusterEndpoint" {:query-params {:DBClusterIdentifier ""
                                                                                          :DBClusterEndpointIdentifier ""
                                                                                          :EndpointType ""
                                                                                          :Action ""
                                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?DBClusterIdentifier=&DBClusterEndpointIdentifier=&EndpointType=&Action=&Version=#Action=CreateDBClusterEndpoint"

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}}/?DBClusterIdentifier=&DBClusterEndpointIdentifier=&EndpointType=&Action=&Version=#Action=CreateDBClusterEndpoint"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBClusterIdentifier=&DBClusterEndpointIdentifier=&EndpointType=&Action=&Version=#Action=CreateDBClusterEndpoint");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?DBClusterIdentifier=&DBClusterEndpointIdentifier=&EndpointType=&Action=&Version=#Action=CreateDBClusterEndpoint"

	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/?DBClusterIdentifier=&DBClusterEndpointIdentifier=&EndpointType=&Action=&Version= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBClusterIdentifier=&DBClusterEndpointIdentifier=&EndpointType=&Action=&Version=#Action=CreateDBClusterEndpoint"))
    .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}}/?DBClusterIdentifier=&DBClusterEndpointIdentifier=&EndpointType=&Action=&Version=#Action=CreateDBClusterEndpoint")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBClusterIdentifier=&DBClusterEndpointIdentifier=&EndpointType=&Action=&Version=#Action=CreateDBClusterEndpoint")
  .asString();
const 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}}/?DBClusterIdentifier=&DBClusterEndpointIdentifier=&EndpointType=&Action=&Version=#Action=CreateDBClusterEndpoint');

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateDBClusterEndpoint',
  params: {
    DBClusterIdentifier: '',
    DBClusterEndpointIdentifier: '',
    EndpointType: '',
    Action: '',
    Version: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBClusterIdentifier=&DBClusterEndpointIdentifier=&EndpointType=&Action=&Version=#Action=CreateDBClusterEndpoint';
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}}/?DBClusterIdentifier=&DBClusterEndpointIdentifier=&EndpointType=&Action=&Version=#Action=CreateDBClusterEndpoint',
  method: 'GET',
  headers: {}
};

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

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

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

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

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

  res.on('data', function (chunk) {
    chunks.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=CreateDBClusterEndpoint',
  qs: {
    DBClusterIdentifier: '',
    DBClusterEndpointIdentifier: '',
    EndpointType: '',
    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=CreateDBClusterEndpoint');

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

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=CreateDBClusterEndpoint',
  params: {
    DBClusterIdentifier: '',
    DBClusterEndpointIdentifier: '',
    EndpointType: '',
    Action: '',
    Version: ''
  }
};

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

const url = '{{baseUrl}}/?DBClusterIdentifier=&DBClusterEndpointIdentifier=&EndpointType=&Action=&Version=#Action=CreateDBClusterEndpoint';
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}}/?DBClusterIdentifier=&DBClusterEndpointIdentifier=&EndpointType=&Action=&Version=#Action=CreateDBClusterEndpoint"]
                                                       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}}/?DBClusterIdentifier=&DBClusterEndpointIdentifier=&EndpointType=&Action=&Version=#Action=CreateDBClusterEndpoint" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBClusterIdentifier=&DBClusterEndpointIdentifier=&EndpointType=&Action=&Version=#Action=CreateDBClusterEndpoint",
  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}}/?DBClusterIdentifier=&DBClusterEndpointIdentifier=&EndpointType=&Action=&Version=#Action=CreateDBClusterEndpoint');

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

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

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

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

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

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

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

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

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

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

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

querystring = {"DBClusterIdentifier":"","DBClusterEndpointIdentifier":"","EndpointType":"","Action":"","Version":""}

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

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

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

queryString <- list(
  DBClusterIdentifier = "",
  DBClusterEndpointIdentifier = "",
  EndpointType = "",
  Action = "",
  Version = ""
)

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

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

url = URI("{{baseUrl}}/?DBClusterIdentifier=&DBClusterEndpointIdentifier=&EndpointType=&Action=&Version=#Action=CreateDBClusterEndpoint")

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['DBClusterIdentifier'] = ''
  req.params['DBClusterEndpointIdentifier'] = ''
  req.params['EndpointType'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("DBClusterIdentifier", ""),
        ("DBClusterEndpointIdentifier", ""),
        ("EndpointType", ""),
        ("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}}/?DBClusterIdentifier=&DBClusterEndpointIdentifier=&EndpointType=&Action=&Version=#Action=CreateDBClusterEndpoint'
http GET '{{baseUrl}}/?DBClusterIdentifier=&DBClusterEndpointIdentifier=&EndpointType=&Action=&Version=#Action=CreateDBClusterEndpoint'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBClusterIdentifier=&DBClusterEndpointIdentifier=&EndpointType=&Action=&Version=#Action=CreateDBClusterEndpoint'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBClusterIdentifier=&DBClusterEndpointIdentifier=&EndpointType=&Action=&Version=#Action=CreateDBClusterEndpoint")! 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_CreateDBClusterParameterGroup
{{baseUrl}}/#Action=CreateDBClusterParameterGroup
QUERY PARAMS
DBClusterParameterGroupName
DBParameterGroupFamily
Description
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

(client/get "{{baseUrl}}/#Action=CreateDBClusterParameterGroup" {:query-params {:DBClusterParameterGroupName ""
                                                                                                :DBParameterGroupFamily ""
                                                                                                :Description ""
                                                                                                :Action ""
                                                                                                :Version ""}})
require "http/client"

url = "{{baseUrl}}/?DBClusterParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBClusterParameterGroup"

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}}/?DBClusterParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBClusterParameterGroup"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBClusterParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBClusterParameterGroup");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?DBClusterParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBClusterParameterGroup"

	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/?DBClusterParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBClusterParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBClusterParameterGroup"))
    .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}}/?DBClusterParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBClusterParameterGroup")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBClusterParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBClusterParameterGroup")
  .asString();
const 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}}/?DBClusterParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBClusterParameterGroup');

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateDBClusterParameterGroup',
  params: {
    DBClusterParameterGroupName: '',
    DBParameterGroupFamily: '',
    Description: '',
    Action: '',
    Version: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBClusterParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBClusterParameterGroup';
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}}/?DBClusterParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBClusterParameterGroup',
  method: 'GET',
  headers: {}
};

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

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

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

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?DBClusterParameterGroupName=&DBParameterGroupFamily=&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=CreateDBClusterParameterGroup',
  qs: {
    DBClusterParameterGroupName: '',
    DBParameterGroupFamily: '',
    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=CreateDBClusterParameterGroup');

req.query({
  DBClusterParameterGroupName: '',
  DBParameterGroupFamily: '',
  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=CreateDBClusterParameterGroup',
  params: {
    DBClusterParameterGroupName: '',
    DBParameterGroupFamily: '',
    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}}/?DBClusterParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBClusterParameterGroup';
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}}/?DBClusterParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBClusterParameterGroup"]
                                                       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}}/?DBClusterParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBClusterParameterGroup" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBClusterParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBClusterParameterGroup",
  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}}/?DBClusterParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBClusterParameterGroup');

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

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

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

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

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

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

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

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

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

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

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

querystring = {"DBClusterParameterGroupName":"","DBParameterGroupFamily":"","Description":"","Action":"","Version":""}

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

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

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

queryString <- list(
  DBClusterParameterGroupName = "",
  DBParameterGroupFamily = "",
  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}}/?DBClusterParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBClusterParameterGroup")

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['DBClusterParameterGroupName'] = ''
  req.params['DBParameterGroupFamily'] = ''
  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=CreateDBClusterParameterGroup";

    let querystring = [
        ("DBClusterParameterGroupName", ""),
        ("DBParameterGroupFamily", ""),
        ("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}}/?DBClusterParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBClusterParameterGroup'
http GET '{{baseUrl}}/?DBClusterParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBClusterParameterGroup'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBClusterParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBClusterParameterGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBClusterParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBClusterParameterGroup")! 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_CreateDBClusterSnapshot
{{baseUrl}}/#Action=CreateDBClusterSnapshot
QUERY PARAMS
DBClusterSnapshotIdentifier
DBClusterIdentifier
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

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

url = "{{baseUrl}}/?DBClusterSnapshotIdentifier=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBClusterSnapshot"

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}}/?DBClusterSnapshotIdentifier=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBClusterSnapshot"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBClusterSnapshotIdentifier=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBClusterSnapshot");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?DBClusterSnapshotIdentifier=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBClusterSnapshot"

	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/?DBClusterSnapshotIdentifier=&DBClusterIdentifier=&Action=&Version= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBClusterSnapshotIdentifier=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBClusterSnapshot"))
    .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}}/?DBClusterSnapshotIdentifier=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBClusterSnapshot")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBClusterSnapshotIdentifier=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBClusterSnapshot")
  .asString();
const 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}}/?DBClusterSnapshotIdentifier=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBClusterSnapshot');

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

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBClusterSnapshotIdentifier=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBClusterSnapshot';
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}}/?DBClusterSnapshotIdentifier=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBClusterSnapshot',
  method: 'GET',
  headers: {}
};

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

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

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

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

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

  res.on('data', function (chunk) {
    chunks.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=CreateDBClusterSnapshot',
  qs: {
    DBClusterSnapshotIdentifier: '',
    DBClusterIdentifier: '',
    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=CreateDBClusterSnapshot');

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

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=CreateDBClusterSnapshot',
  params: {
    DBClusterSnapshotIdentifier: '',
    DBClusterIdentifier: '',
    Action: '',
    Version: ''
  }
};

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

const url = '{{baseUrl}}/?DBClusterSnapshotIdentifier=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBClusterSnapshot';
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}}/?DBClusterSnapshotIdentifier=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBClusterSnapshot"]
                                                       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}}/?DBClusterSnapshotIdentifier=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBClusterSnapshot" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBClusterSnapshotIdentifier=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBClusterSnapshot",
  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}}/?DBClusterSnapshotIdentifier=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBClusterSnapshot');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

url = URI("{{baseUrl}}/?DBClusterSnapshotIdentifier=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBClusterSnapshot")

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['DBClusterSnapshotIdentifier'] = ''
  req.params['DBClusterIdentifier'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("DBClusterSnapshotIdentifier", ""),
        ("DBClusterIdentifier", ""),
        ("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}}/?DBClusterSnapshotIdentifier=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBClusterSnapshot'
http GET '{{baseUrl}}/?DBClusterSnapshotIdentifier=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBClusterSnapshot'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBClusterSnapshotIdentifier=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBClusterSnapshot'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBClusterSnapshotIdentifier=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBClusterSnapshot")! 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_CreateDBInstance
{{baseUrl}}/#Action=CreateDBInstance
QUERY PARAMS
DBInstanceIdentifier
DBInstanceClass
Engine
DBClusterIdentifier
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?DBInstanceIdentifier=&DBInstanceClass=&Engine=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBInstance");

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

(client/get "{{baseUrl}}/#Action=CreateDBInstance" {:query-params {:DBInstanceIdentifier ""
                                                                                   :DBInstanceClass ""
                                                                                   :Engine ""
                                                                                   :DBClusterIdentifier ""
                                                                                   :Action ""
                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?DBInstanceIdentifier=&DBInstanceClass=&Engine=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBInstance"

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}}/?DBInstanceIdentifier=&DBInstanceClass=&Engine=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBInstance"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBInstanceIdentifier=&DBInstanceClass=&Engine=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBInstance");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?DBInstanceIdentifier=&DBInstanceClass=&Engine=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBInstance"

	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/?DBInstanceIdentifier=&DBInstanceClass=&Engine=&DBClusterIdentifier=&Action=&Version= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBInstanceIdentifier=&DBInstanceClass=&Engine=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBInstance"))
    .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}}/?DBInstanceIdentifier=&DBInstanceClass=&Engine=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBInstance")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBInstanceIdentifier=&DBInstanceClass=&Engine=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBInstance")
  .asString();
const 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}}/?DBInstanceIdentifier=&DBInstanceClass=&Engine=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBInstance');

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateDBInstance',
  params: {
    DBInstanceIdentifier: '',
    DBInstanceClass: '',
    Engine: '',
    DBClusterIdentifier: '',
    Action: '',
    Version: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBInstanceIdentifier=&DBInstanceClass=&Engine=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBInstance';
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}}/?DBInstanceIdentifier=&DBInstanceClass=&Engine=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBInstance',
  method: 'GET',
  headers: {}
};

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

val request = Request.Builder()
  .url("{{baseUrl}}/?DBInstanceIdentifier=&DBInstanceClass=&Engine=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBInstance")
  .get()
  .build()

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

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

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

  res.on('data', function (chunk) {
    chunks.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=CreateDBInstance',
  qs: {
    DBInstanceIdentifier: '',
    DBInstanceClass: '',
    Engine: '',
    DBClusterIdentifier: '',
    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=CreateDBInstance');

req.query({
  DBInstanceIdentifier: '',
  DBInstanceClass: '',
  Engine: '',
  DBClusterIdentifier: '',
  Action: '',
  Version: ''
});

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=CreateDBInstance',
  params: {
    DBInstanceIdentifier: '',
    DBInstanceClass: '',
    Engine: '',
    DBClusterIdentifier: '',
    Action: '',
    Version: ''
  }
};

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

const url = '{{baseUrl}}/?DBInstanceIdentifier=&DBInstanceClass=&Engine=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBInstance';
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}}/?DBInstanceIdentifier=&DBInstanceClass=&Engine=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBInstance"]
                                                       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}}/?DBInstanceIdentifier=&DBInstanceClass=&Engine=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBInstance" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBInstanceIdentifier=&DBInstanceClass=&Engine=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBInstance",
  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}}/?DBInstanceIdentifier=&DBInstanceClass=&Engine=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBInstance');

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

$request->setQueryData([
  'DBInstanceIdentifier' => '',
  'DBInstanceClass' => '',
  'Engine' => '',
  'DBClusterIdentifier' => '',
  'Action' => '',
  'Version' => ''
]);

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

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

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

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

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

conn.request("GET", "/baseUrl/?DBInstanceIdentifier=&DBInstanceClass=&Engine=&DBClusterIdentifier=&Action=&Version=")

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

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

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

querystring = {"DBInstanceIdentifier":"","DBInstanceClass":"","Engine":"","DBClusterIdentifier":"","Action":"","Version":""}

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

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

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

queryString <- list(
  DBInstanceIdentifier = "",
  DBInstanceClass = "",
  Engine = "",
  DBClusterIdentifier = "",
  Action = "",
  Version = ""
)

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

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

url = URI("{{baseUrl}}/?DBInstanceIdentifier=&DBInstanceClass=&Engine=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBInstance")

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['DBInstanceIdentifier'] = ''
  req.params['DBInstanceClass'] = ''
  req.params['Engine'] = ''
  req.params['DBClusterIdentifier'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("DBInstanceIdentifier", ""),
        ("DBInstanceClass", ""),
        ("Engine", ""),
        ("DBClusterIdentifier", ""),
        ("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}}/?DBInstanceIdentifier=&DBInstanceClass=&Engine=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBInstance'
http GET '{{baseUrl}}/?DBInstanceIdentifier=&DBInstanceClass=&Engine=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBInstance'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBInstanceIdentifier=&DBInstanceClass=&Engine=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBInstance'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBInstanceIdentifier=&DBInstanceClass=&Engine=&DBClusterIdentifier=&Action=&Version=#Action=CreateDBInstance")! 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_CreateDBParameterGroup
{{baseUrl}}/#Action=CreateDBParameterGroup
QUERY PARAMS
DBParameterGroupName
DBParameterGroupFamily
Description
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

(client/get "{{baseUrl}}/#Action=CreateDBParameterGroup" {:query-params {:DBParameterGroupName ""
                                                                                         :DBParameterGroupFamily ""
                                                                                         :Description ""
                                                                                         :Action ""
                                                                                         :Version ""}})
require "http/client"

url = "{{baseUrl}}/?DBParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBParameterGroup"

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}}/?DBParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBParameterGroup"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBParameterGroup");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?DBParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBParameterGroup"

	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/?DBParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBParameterGroup"))
    .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}}/?DBParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBParameterGroup")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBParameterGroup")
  .asString();
const 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}}/?DBParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBParameterGroup');

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateDBParameterGroup',
  params: {
    DBParameterGroupName: '',
    DBParameterGroupFamily: '',
    Description: '',
    Action: '',
    Version: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBParameterGroup';
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}}/?DBParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBParameterGroup',
  method: 'GET',
  headers: {}
};

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

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

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

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?DBParameterGroupName=&DBParameterGroupFamily=&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=CreateDBParameterGroup',
  qs: {
    DBParameterGroupName: '',
    DBParameterGroupFamily: '',
    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=CreateDBParameterGroup');

req.query({
  DBParameterGroupName: '',
  DBParameterGroupFamily: '',
  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=CreateDBParameterGroup',
  params: {
    DBParameterGroupName: '',
    DBParameterGroupFamily: '',
    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}}/?DBParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBParameterGroup';
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}}/?DBParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBParameterGroup"]
                                                       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}}/?DBParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBParameterGroup" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBParameterGroup",
  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}}/?DBParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBParameterGroup');

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

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

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

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

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

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

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

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

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

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

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

querystring = {"DBParameterGroupName":"","DBParameterGroupFamily":"","Description":"","Action":"","Version":""}

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

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

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

queryString <- list(
  DBParameterGroupName = "",
  DBParameterGroupFamily = "",
  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}}/?DBParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBParameterGroup")

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['DBParameterGroupName'] = ''
  req.params['DBParameterGroupFamily'] = ''
  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=CreateDBParameterGroup";

    let querystring = [
        ("DBParameterGroupName", ""),
        ("DBParameterGroupFamily", ""),
        ("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}}/?DBParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBParameterGroup'
http GET '{{baseUrl}}/?DBParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBParameterGroup'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBParameterGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBParameterGroupName=&DBParameterGroupFamily=&Description=&Action=&Version=#Action=CreateDBParameterGroup")! 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_CreateDBSubnetGroup
{{baseUrl}}/#Action=CreateDBSubnetGroup
QUERY PARAMS
DBSubnetGroupName
DBSubnetGroupDescription
SubnetIds
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

(client/get "{{baseUrl}}/#Action=CreateDBSubnetGroup" {:query-params {:DBSubnetGroupName ""
                                                                                      :DBSubnetGroupDescription ""
                                                                                      :SubnetIds ""
                                                                                      :Action ""
                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?DBSubnetGroupName=&DBSubnetGroupDescription=&SubnetIds=&Action=&Version=#Action=CreateDBSubnetGroup"

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}}/?DBSubnetGroupName=&DBSubnetGroupDescription=&SubnetIds=&Action=&Version=#Action=CreateDBSubnetGroup"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBSubnetGroupName=&DBSubnetGroupDescription=&SubnetIds=&Action=&Version=#Action=CreateDBSubnetGroup");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?DBSubnetGroupName=&DBSubnetGroupDescription=&SubnetIds=&Action=&Version=#Action=CreateDBSubnetGroup"

	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/?DBSubnetGroupName=&DBSubnetGroupDescription=&SubnetIds=&Action=&Version= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBSubnetGroupName=&DBSubnetGroupDescription=&SubnetIds=&Action=&Version=#Action=CreateDBSubnetGroup"))
    .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}}/?DBSubnetGroupName=&DBSubnetGroupDescription=&SubnetIds=&Action=&Version=#Action=CreateDBSubnetGroup")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBSubnetGroupName=&DBSubnetGroupDescription=&SubnetIds=&Action=&Version=#Action=CreateDBSubnetGroup")
  .asString();
const 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}}/?DBSubnetGroupName=&DBSubnetGroupDescription=&SubnetIds=&Action=&Version=#Action=CreateDBSubnetGroup');

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=CreateDBSubnetGroup',
  params: {
    DBSubnetGroupName: '',
    DBSubnetGroupDescription: '',
    SubnetIds: '',
    Action: '',
    Version: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBSubnetGroupName=&DBSubnetGroupDescription=&SubnetIds=&Action=&Version=#Action=CreateDBSubnetGroup';
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}}/?DBSubnetGroupName=&DBSubnetGroupDescription=&SubnetIds=&Action=&Version=#Action=CreateDBSubnetGroup',
  method: 'GET',
  headers: {}
};

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

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

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

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

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

  res.on('data', function (chunk) {
    chunks.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=CreateDBSubnetGroup',
  qs: {
    DBSubnetGroupName: '',
    DBSubnetGroupDescription: '',
    SubnetIds: '',
    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=CreateDBSubnetGroup');

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

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=CreateDBSubnetGroup',
  params: {
    DBSubnetGroupName: '',
    DBSubnetGroupDescription: '',
    SubnetIds: '',
    Action: '',
    Version: ''
  }
};

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

const url = '{{baseUrl}}/?DBSubnetGroupName=&DBSubnetGroupDescription=&SubnetIds=&Action=&Version=#Action=CreateDBSubnetGroup';
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}}/?DBSubnetGroupName=&DBSubnetGroupDescription=&SubnetIds=&Action=&Version=#Action=CreateDBSubnetGroup"]
                                                       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}}/?DBSubnetGroupName=&DBSubnetGroupDescription=&SubnetIds=&Action=&Version=#Action=CreateDBSubnetGroup" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBSubnetGroupName=&DBSubnetGroupDescription=&SubnetIds=&Action=&Version=#Action=CreateDBSubnetGroup",
  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}}/?DBSubnetGroupName=&DBSubnetGroupDescription=&SubnetIds=&Action=&Version=#Action=CreateDBSubnetGroup');

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

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

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

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

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

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

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

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

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

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

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

querystring = {"DBSubnetGroupName":"","DBSubnetGroupDescription":"","SubnetIds":"","Action":"","Version":""}

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

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

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

queryString <- list(
  DBSubnetGroupName = "",
  DBSubnetGroupDescription = "",
  SubnetIds = "",
  Action = "",
  Version = ""
)

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

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

url = URI("{{baseUrl}}/?DBSubnetGroupName=&DBSubnetGroupDescription=&SubnetIds=&Action=&Version=#Action=CreateDBSubnetGroup")

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['DBSubnetGroupName'] = ''
  req.params['DBSubnetGroupDescription'] = ''
  req.params['SubnetIds'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("DBSubnetGroupName", ""),
        ("DBSubnetGroupDescription", ""),
        ("SubnetIds", ""),
        ("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}}/?DBSubnetGroupName=&DBSubnetGroupDescription=&SubnetIds=&Action=&Version=#Action=CreateDBSubnetGroup'
http GET '{{baseUrl}}/?DBSubnetGroupName=&DBSubnetGroupDescription=&SubnetIds=&Action=&Version=#Action=CreateDBSubnetGroup'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBSubnetGroupName=&DBSubnetGroupDescription=&SubnetIds=&Action=&Version=#Action=CreateDBSubnetGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBSubnetGroupName=&DBSubnetGroupDescription=&SubnetIds=&Action=&Version=#Action=CreateDBSubnetGroup")! 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_CreateEventSubscription
{{baseUrl}}/#Action=CreateEventSubscription
QUERY PARAMS
SubscriptionName
SnsTopicArn
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

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

url = "{{baseUrl}}/?SubscriptionName=&SnsTopicArn=&Action=&Version=#Action=CreateEventSubscription"

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}}/?SubscriptionName=&SnsTopicArn=&Action=&Version=#Action=CreateEventSubscription"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?SubscriptionName=&SnsTopicArn=&Action=&Version=#Action=CreateEventSubscription");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/?SubscriptionName=&SnsTopicArn=&Action=&Version=#Action=CreateEventSubscription"

	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/?SubscriptionName=&SnsTopicArn=&Action=&Version= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?SubscriptionName=&SnsTopicArn=&Action=&Version=#Action=CreateEventSubscription"))
    .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}}/?SubscriptionName=&SnsTopicArn=&Action=&Version=#Action=CreateEventSubscription")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?SubscriptionName=&SnsTopicArn=&Action=&Version=#Action=CreateEventSubscription")
  .asString();
const 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}}/?SubscriptionName=&SnsTopicArn=&Action=&Version=#Action=CreateEventSubscription');

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

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?SubscriptionName=&SnsTopicArn=&Action=&Version=#Action=CreateEventSubscription';
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}}/?SubscriptionName=&SnsTopicArn=&Action=&Version=#Action=CreateEventSubscription',
  method: 'GET',
  headers: {}
};

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

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

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

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

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

  res.on('data', function (chunk) {
    chunks.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=CreateEventSubscription',
  qs: {SubscriptionName: '', SnsTopicArn: '', 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=CreateEventSubscription');

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

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=CreateEventSubscription',
  params: {SubscriptionName: '', SnsTopicArn: '', Action: '', Version: ''}
};

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

const url = '{{baseUrl}}/?SubscriptionName=&SnsTopicArn=&Action=&Version=#Action=CreateEventSubscription';
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}}/?SubscriptionName=&SnsTopicArn=&Action=&Version=#Action=CreateEventSubscription"]
                                                       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}}/?SubscriptionName=&SnsTopicArn=&Action=&Version=#Action=CreateEventSubscription" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?SubscriptionName=&SnsTopicArn=&Action=&Version=#Action=CreateEventSubscription",
  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}}/?SubscriptionName=&SnsTopicArn=&Action=&Version=#Action=CreateEventSubscription');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

url = URI("{{baseUrl}}/?SubscriptionName=&SnsTopicArn=&Action=&Version=#Action=CreateEventSubscription")

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['SubscriptionName'] = ''
  req.params['SnsTopicArn'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("SubscriptionName", ""),
        ("SnsTopicArn", ""),
        ("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}}/?SubscriptionName=&SnsTopicArn=&Action=&Version=#Action=CreateEventSubscription'
http GET '{{baseUrl}}/?SubscriptionName=&SnsTopicArn=&Action=&Version=#Action=CreateEventSubscription'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?SubscriptionName=&SnsTopicArn=&Action=&Version=#Action=CreateEventSubscription'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?SubscriptionName=&SnsTopicArn=&Action=&Version=#Action=CreateEventSubscription")! 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_CreateGlobalCluster
{{baseUrl}}/#Action=CreateGlobalCluster
QUERY PARAMS
GlobalClusterIdentifier
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

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

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

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}}/?GlobalClusterIdentifier=&Action=&Version=#Action=CreateGlobalCluster"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=CreateGlobalCluster");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

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

	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/?GlobalClusterIdentifier=&Action=&Version= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=CreateGlobalCluster"))
    .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}}/?GlobalClusterIdentifier=&Action=&Version=#Action=CreateGlobalCluster")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=CreateGlobalCluster")
  .asString();
const 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}}/?GlobalClusterIdentifier=&Action=&Version=#Action=CreateGlobalCluster');

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

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=CreateGlobalCluster';
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}}/?GlobalClusterIdentifier=&Action=&Version=#Action=CreateGlobalCluster',
  method: 'GET',
  headers: {}
};

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

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

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

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

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

  res.on('data', function (chunk) {
    chunks.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=CreateGlobalCluster',
  qs: {GlobalClusterIdentifier: '', 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=CreateGlobalCluster');

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

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=CreateGlobalCluster',
  params: {GlobalClusterIdentifier: '', Action: '', Version: ''}
};

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

const url = '{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=CreateGlobalCluster';
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}}/?GlobalClusterIdentifier=&Action=&Version=#Action=CreateGlobalCluster"]
                                                       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}}/?GlobalClusterIdentifier=&Action=&Version=#Action=CreateGlobalCluster" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=CreateGlobalCluster",
  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}}/?GlobalClusterIdentifier=&Action=&Version=#Action=CreateGlobalCluster');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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['GlobalClusterIdentifier'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("GlobalClusterIdentifier", ""),
        ("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}}/?GlobalClusterIdentifier=&Action=&Version=#Action=CreateGlobalCluster'
http GET '{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=CreateGlobalCluster'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=CreateGlobalCluster'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=CreateGlobalCluster")! 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_DeleteDBCluster
{{baseUrl}}/#Action=DeleteDBCluster
QUERY PARAMS
DBClusterIdentifier
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

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

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

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}}/?DBClusterIdentifier=&Action=&Version=#Action=DeleteDBCluster"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=DeleteDBCluster");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

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

	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/?DBClusterIdentifier=&Action=&Version= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=DeleteDBCluster"))
    .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}}/?DBClusterIdentifier=&Action=&Version=#Action=DeleteDBCluster")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=DeleteDBCluster")
  .asString();
const 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}}/?DBClusterIdentifier=&Action=&Version=#Action=DeleteDBCluster');

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

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=DeleteDBCluster';
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}}/?DBClusterIdentifier=&Action=&Version=#Action=DeleteDBCluster',
  method: 'GET',
  headers: {}
};

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

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

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

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

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

  res.on('data', function (chunk) {
    chunks.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=DeleteDBCluster',
  qs: {DBClusterIdentifier: '', 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=DeleteDBCluster');

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

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=DeleteDBCluster',
  params: {DBClusterIdentifier: '', Action: '', Version: ''}
};

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

const url = '{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=DeleteDBCluster';
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}}/?DBClusterIdentifier=&Action=&Version=#Action=DeleteDBCluster"]
                                                       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}}/?DBClusterIdentifier=&Action=&Version=#Action=DeleteDBCluster" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=DeleteDBCluster",
  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}}/?DBClusterIdentifier=&Action=&Version=#Action=DeleteDBCluster');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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['DBClusterIdentifier'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("DBClusterIdentifier", ""),
        ("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}}/?DBClusterIdentifier=&Action=&Version=#Action=DeleteDBCluster'
http GET '{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=DeleteDBCluster'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=DeleteDBCluster'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=DeleteDBCluster")! 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_DeleteDBClusterEndpoint
{{baseUrl}}/#Action=DeleteDBClusterEndpoint
QUERY PARAMS
DBClusterEndpointIdentifier
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

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

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

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}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=DeleteDBClusterEndpoint"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=DeleteDBClusterEndpoint");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

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

	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/?DBClusterEndpointIdentifier=&Action=&Version= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=DeleteDBClusterEndpoint"))
    .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}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=DeleteDBClusterEndpoint")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=DeleteDBClusterEndpoint")
  .asString();
const 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}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=DeleteDBClusterEndpoint');

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

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=DeleteDBClusterEndpoint';
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}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=DeleteDBClusterEndpoint',
  method: 'GET',
  headers: {}
};

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

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

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

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

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

  res.on('data', function (chunk) {
    chunks.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=DeleteDBClusterEndpoint',
  qs: {DBClusterEndpointIdentifier: '', 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=DeleteDBClusterEndpoint');

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

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=DeleteDBClusterEndpoint',
  params: {DBClusterEndpointIdentifier: '', Action: '', Version: ''}
};

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

const url = '{{baseUrl}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=DeleteDBClusterEndpoint';
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}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=DeleteDBClusterEndpoint"]
                                                       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}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=DeleteDBClusterEndpoint" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=DeleteDBClusterEndpoint",
  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}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=DeleteDBClusterEndpoint');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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['DBClusterEndpointIdentifier'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("DBClusterEndpointIdentifier", ""),
        ("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}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=DeleteDBClusterEndpoint'
http GET '{{baseUrl}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=DeleteDBClusterEndpoint'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=DeleteDBClusterEndpoint'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=DeleteDBClusterEndpoint")! 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_DeleteDBClusterParameterGroup
{{baseUrl}}/#Action=DeleteDBClusterParameterGroup
QUERY PARAMS
DBClusterParameterGroupName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

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

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

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}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DeleteDBClusterParameterGroup"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DeleteDBClusterParameterGroup");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

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

	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/?DBClusterParameterGroupName=&Action=&Version= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DeleteDBClusterParameterGroup"))
    .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}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DeleteDBClusterParameterGroup")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DeleteDBClusterParameterGroup")
  .asString();
const 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}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DeleteDBClusterParameterGroup');

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

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DeleteDBClusterParameterGroup';
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}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DeleteDBClusterParameterGroup',
  method: 'GET',
  headers: {}
};

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

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

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

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

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

  res.on('data', function (chunk) {
    chunks.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=DeleteDBClusterParameterGroup',
  qs: {DBClusterParameterGroupName: '', 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=DeleteDBClusterParameterGroup');

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

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=DeleteDBClusterParameterGroup',
  params: {DBClusterParameterGroupName: '', Action: '', Version: ''}
};

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

const url = '{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DeleteDBClusterParameterGroup';
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}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DeleteDBClusterParameterGroup"]
                                                       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}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DeleteDBClusterParameterGroup" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DeleteDBClusterParameterGroup",
  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}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DeleteDBClusterParameterGroup');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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['DBClusterParameterGroupName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("DBClusterParameterGroupName", ""),
        ("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}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DeleteDBClusterParameterGroup'
http GET '{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DeleteDBClusterParameterGroup'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DeleteDBClusterParameterGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DeleteDBClusterParameterGroup")! 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_DeleteDBClusterSnapshot
{{baseUrl}}/#Action=DeleteDBClusterSnapshot
QUERY PARAMS
DBClusterSnapshotIdentifier
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

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

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

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}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DeleteDBClusterSnapshot"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DeleteDBClusterSnapshot");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

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

	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/?DBClusterSnapshotIdentifier=&Action=&Version= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DeleteDBClusterSnapshot"))
    .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}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DeleteDBClusterSnapshot")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DeleteDBClusterSnapshot")
  .asString();
const 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}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DeleteDBClusterSnapshot');

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

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DeleteDBClusterSnapshot';
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}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DeleteDBClusterSnapshot',
  method: 'GET',
  headers: {}
};

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

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

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

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

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

  res.on('data', function (chunk) {
    chunks.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=DeleteDBClusterSnapshot',
  qs: {DBClusterSnapshotIdentifier: '', 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=DeleteDBClusterSnapshot');

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

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=DeleteDBClusterSnapshot',
  params: {DBClusterSnapshotIdentifier: '', Action: '', Version: ''}
};

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

const url = '{{baseUrl}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DeleteDBClusterSnapshot';
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}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DeleteDBClusterSnapshot"]
                                                       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}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DeleteDBClusterSnapshot" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DeleteDBClusterSnapshot",
  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}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DeleteDBClusterSnapshot');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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['DBClusterSnapshotIdentifier'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("DBClusterSnapshotIdentifier", ""),
        ("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}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DeleteDBClusterSnapshot'
http GET '{{baseUrl}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DeleteDBClusterSnapshot'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DeleteDBClusterSnapshot'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DeleteDBClusterSnapshot")! 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_DeleteDBInstance
{{baseUrl}}/#Action=DeleteDBInstance
QUERY PARAMS
DBInstanceIdentifier
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

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

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

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}}/?DBInstanceIdentifier=&Action=&Version=#Action=DeleteDBInstance"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=DeleteDBInstance");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

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

	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/?DBInstanceIdentifier=&Action=&Version= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=DeleteDBInstance"))
    .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}}/?DBInstanceIdentifier=&Action=&Version=#Action=DeleteDBInstance")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=DeleteDBInstance")
  .asString();
const 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}}/?DBInstanceIdentifier=&Action=&Version=#Action=DeleteDBInstance');

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

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=DeleteDBInstance';
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}}/?DBInstanceIdentifier=&Action=&Version=#Action=DeleteDBInstance',
  method: 'GET',
  headers: {}
};

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

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

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

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

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

  res.on('data', function (chunk) {
    chunks.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=DeleteDBInstance',
  qs: {DBInstanceIdentifier: '', 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=DeleteDBInstance');

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

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=DeleteDBInstance',
  params: {DBInstanceIdentifier: '', Action: '', Version: ''}
};

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

const url = '{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=DeleteDBInstance';
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}}/?DBInstanceIdentifier=&Action=&Version=#Action=DeleteDBInstance"]
                                                       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}}/?DBInstanceIdentifier=&Action=&Version=#Action=DeleteDBInstance" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=DeleteDBInstance",
  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}}/?DBInstanceIdentifier=&Action=&Version=#Action=DeleteDBInstance');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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['DBInstanceIdentifier'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("DBInstanceIdentifier", ""),
        ("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}}/?DBInstanceIdentifier=&Action=&Version=#Action=DeleteDBInstance'
http GET '{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=DeleteDBInstance'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=DeleteDBInstance'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=DeleteDBInstance")! 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_DeleteDBParameterGroup
{{baseUrl}}/#Action=DeleteDBParameterGroup
QUERY PARAMS
DBParameterGroupName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

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

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

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}}/?DBParameterGroupName=&Action=&Version=#Action=DeleteDBParameterGroup"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=DeleteDBParameterGroup");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

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

	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/?DBParameterGroupName=&Action=&Version= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=DeleteDBParameterGroup"))
    .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}}/?DBParameterGroupName=&Action=&Version=#Action=DeleteDBParameterGroup")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=DeleteDBParameterGroup")
  .asString();
const 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}}/?DBParameterGroupName=&Action=&Version=#Action=DeleteDBParameterGroup');

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

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=DeleteDBParameterGroup';
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}}/?DBParameterGroupName=&Action=&Version=#Action=DeleteDBParameterGroup',
  method: 'GET',
  headers: {}
};

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

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

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

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

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

  res.on('data', function (chunk) {
    chunks.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=DeleteDBParameterGroup',
  qs: {DBParameterGroupName: '', 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=DeleteDBParameterGroup');

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

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=DeleteDBParameterGroup',
  params: {DBParameterGroupName: '', Action: '', Version: ''}
};

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

const url = '{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=DeleteDBParameterGroup';
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}}/?DBParameterGroupName=&Action=&Version=#Action=DeleteDBParameterGroup"]
                                                       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}}/?DBParameterGroupName=&Action=&Version=#Action=DeleteDBParameterGroup" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=DeleteDBParameterGroup",
  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}}/?DBParameterGroupName=&Action=&Version=#Action=DeleteDBParameterGroup');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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['DBParameterGroupName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("DBParameterGroupName", ""),
        ("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}}/?DBParameterGroupName=&Action=&Version=#Action=DeleteDBParameterGroup'
http GET '{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=DeleteDBParameterGroup'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=DeleteDBParameterGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=DeleteDBParameterGroup")! 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_DeleteDBSubnetGroup
{{baseUrl}}/#Action=DeleteDBSubnetGroup
QUERY PARAMS
DBSubnetGroupName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

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

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

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}}/?DBSubnetGroupName=&Action=&Version=#Action=DeleteDBSubnetGroup"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBSubnetGroupName=&Action=&Version=#Action=DeleteDBSubnetGroup");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

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

	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/?DBSubnetGroupName=&Action=&Version= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBSubnetGroupName=&Action=&Version=#Action=DeleteDBSubnetGroup"))
    .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}}/?DBSubnetGroupName=&Action=&Version=#Action=DeleteDBSubnetGroup")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBSubnetGroupName=&Action=&Version=#Action=DeleteDBSubnetGroup")
  .asString();
const 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}}/?DBSubnetGroupName=&Action=&Version=#Action=DeleteDBSubnetGroup');

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

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBSubnetGroupName=&Action=&Version=#Action=DeleteDBSubnetGroup';
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}}/?DBSubnetGroupName=&Action=&Version=#Action=DeleteDBSubnetGroup',
  method: 'GET',
  headers: {}
};

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

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

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

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

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

  res.on('data', function (chunk) {
    chunks.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=DeleteDBSubnetGroup',
  qs: {DBSubnetGroupName: '', 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=DeleteDBSubnetGroup');

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

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=DeleteDBSubnetGroup',
  params: {DBSubnetGroupName: '', Action: '', Version: ''}
};

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

const url = '{{baseUrl}}/?DBSubnetGroupName=&Action=&Version=#Action=DeleteDBSubnetGroup';
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}}/?DBSubnetGroupName=&Action=&Version=#Action=DeleteDBSubnetGroup"]
                                                       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}}/?DBSubnetGroupName=&Action=&Version=#Action=DeleteDBSubnetGroup" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBSubnetGroupName=&Action=&Version=#Action=DeleteDBSubnetGroup",
  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}}/?DBSubnetGroupName=&Action=&Version=#Action=DeleteDBSubnetGroup');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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['DBSubnetGroupName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("DBSubnetGroupName", ""),
        ("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}}/?DBSubnetGroupName=&Action=&Version=#Action=DeleteDBSubnetGroup'
http GET '{{baseUrl}}/?DBSubnetGroupName=&Action=&Version=#Action=DeleteDBSubnetGroup'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBSubnetGroupName=&Action=&Version=#Action=DeleteDBSubnetGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBSubnetGroupName=&Action=&Version=#Action=DeleteDBSubnetGroup")! 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_DeleteEventSubscription
{{baseUrl}}/#Action=DeleteEventSubscription
QUERY PARAMS
SubscriptionName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

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

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

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}}/?SubscriptionName=&Action=&Version=#Action=DeleteEventSubscription"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?SubscriptionName=&Action=&Version=#Action=DeleteEventSubscription");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

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

	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/?SubscriptionName=&Action=&Version= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?SubscriptionName=&Action=&Version=#Action=DeleteEventSubscription"))
    .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}}/?SubscriptionName=&Action=&Version=#Action=DeleteEventSubscription")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?SubscriptionName=&Action=&Version=#Action=DeleteEventSubscription")
  .asString();
const 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}}/?SubscriptionName=&Action=&Version=#Action=DeleteEventSubscription');

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

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?SubscriptionName=&Action=&Version=#Action=DeleteEventSubscription';
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}}/?SubscriptionName=&Action=&Version=#Action=DeleteEventSubscription',
  method: 'GET',
  headers: {}
};

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

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

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

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

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

  res.on('data', function (chunk) {
    chunks.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=DeleteEventSubscription',
  qs: {SubscriptionName: '', 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=DeleteEventSubscription');

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

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=DeleteEventSubscription',
  params: {SubscriptionName: '', Action: '', Version: ''}
};

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

const url = '{{baseUrl}}/?SubscriptionName=&Action=&Version=#Action=DeleteEventSubscription';
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}}/?SubscriptionName=&Action=&Version=#Action=DeleteEventSubscription"]
                                                       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}}/?SubscriptionName=&Action=&Version=#Action=DeleteEventSubscription" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?SubscriptionName=&Action=&Version=#Action=DeleteEventSubscription",
  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}}/?SubscriptionName=&Action=&Version=#Action=DeleteEventSubscription');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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['SubscriptionName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("SubscriptionName", ""),
        ("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}}/?SubscriptionName=&Action=&Version=#Action=DeleteEventSubscription'
http GET '{{baseUrl}}/?SubscriptionName=&Action=&Version=#Action=DeleteEventSubscription'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?SubscriptionName=&Action=&Version=#Action=DeleteEventSubscription'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?SubscriptionName=&Action=&Version=#Action=DeleteEventSubscription")! 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_DeleteGlobalCluster
{{baseUrl}}/#Action=DeleteGlobalCluster
QUERY PARAMS
GlobalClusterIdentifier
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

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

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

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}}/?GlobalClusterIdentifier=&Action=&Version=#Action=DeleteGlobalCluster"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=DeleteGlobalCluster");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

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

	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/?GlobalClusterIdentifier=&Action=&Version= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=DeleteGlobalCluster"))
    .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}}/?GlobalClusterIdentifier=&Action=&Version=#Action=DeleteGlobalCluster")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=DeleteGlobalCluster")
  .asString();
const 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}}/?GlobalClusterIdentifier=&Action=&Version=#Action=DeleteGlobalCluster');

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

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=DeleteGlobalCluster';
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}}/?GlobalClusterIdentifier=&Action=&Version=#Action=DeleteGlobalCluster',
  method: 'GET',
  headers: {}
};

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

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

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

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

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

  res.on('data', function (chunk) {
    chunks.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=DeleteGlobalCluster',
  qs: {GlobalClusterIdentifier: '', 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=DeleteGlobalCluster');

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

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=DeleteGlobalCluster',
  params: {GlobalClusterIdentifier: '', Action: '', Version: ''}
};

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

const url = '{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=DeleteGlobalCluster';
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}}/?GlobalClusterIdentifier=&Action=&Version=#Action=DeleteGlobalCluster"]
                                                       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}}/?GlobalClusterIdentifier=&Action=&Version=#Action=DeleteGlobalCluster" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=DeleteGlobalCluster",
  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}}/?GlobalClusterIdentifier=&Action=&Version=#Action=DeleteGlobalCluster');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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['GlobalClusterIdentifier'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("GlobalClusterIdentifier", ""),
        ("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}}/?GlobalClusterIdentifier=&Action=&Version=#Action=DeleteGlobalCluster'
http GET '{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=DeleteGlobalCluster'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=DeleteGlobalCluster'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=DeleteGlobalCluster")! 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_DescribeDBClusterEndpoints
{{baseUrl}}/#Action=DescribeDBClusterEndpoints
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=DescribeDBClusterEndpoints");

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

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

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

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=DescribeDBClusterEndpoints"),
};
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=DescribeDBClusterEndpoints");
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=DescribeDBClusterEndpoints"

	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=DescribeDBClusterEndpoints")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterEndpoints"))
    .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=DescribeDBClusterEndpoints")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterEndpoints")
  .asString();
const 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=DescribeDBClusterEndpoints');

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DescribeDBClusterEndpoints',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterEndpoints';
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=DescribeDBClusterEndpoints',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterEndpoints")
  .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=DescribeDBClusterEndpoints',
  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=DescribeDBClusterEndpoints');

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=DescribeDBClusterEndpoints',
  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=DescribeDBClusterEndpoints';
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=DescribeDBClusterEndpoints"]
                                                       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=DescribeDBClusterEndpoints" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterEndpoints",
  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=DescribeDBClusterEndpoints');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeDBClusterEndpoints');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeDBClusterEndpoints');
$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=DescribeDBClusterEndpoints' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterEndpoints' -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=DescribeDBClusterEndpoints"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeDBClusterEndpoints"

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=DescribeDBClusterEndpoints")

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=DescribeDBClusterEndpoints";

    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=DescribeDBClusterEndpoints'
http GET '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterEndpoints'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterEndpoints'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterEndpoints")! 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_DescribeDBClusterParameterGroups
{{baseUrl}}/#Action=DescribeDBClusterParameterGroups
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=DescribeDBClusterParameterGroups");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DescribeDBClusterParameterGroups" {:query-params {:Action ""
                                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameterGroups"

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=DescribeDBClusterParameterGroups"),
};
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=DescribeDBClusterParameterGroups");
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=DescribeDBClusterParameterGroups"

	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=DescribeDBClusterParameterGroups")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameterGroups"))
    .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=DescribeDBClusterParameterGroups")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameterGroups")
  .asString();
const 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=DescribeDBClusterParameterGroups');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DescribeDBClusterParameterGroups',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameterGroups';
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=DescribeDBClusterParameterGroups',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameterGroups")
  .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=DescribeDBClusterParameterGroups',
  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=DescribeDBClusterParameterGroups');

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=DescribeDBClusterParameterGroups',
  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=DescribeDBClusterParameterGroups';
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=DescribeDBClusterParameterGroups"]
                                                       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=DescribeDBClusterParameterGroups" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameterGroups",
  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=DescribeDBClusterParameterGroups');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeDBClusterParameterGroups');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeDBClusterParameterGroups');
$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=DescribeDBClusterParameterGroups' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameterGroups' -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=DescribeDBClusterParameterGroups"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeDBClusterParameterGroups"

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=DescribeDBClusterParameterGroups")

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=DescribeDBClusterParameterGroups";

    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=DescribeDBClusterParameterGroups'
http GET '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameterGroups'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameterGroups'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameterGroups")! 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_DescribeDBClusterParameters
{{baseUrl}}/#Action=DescribeDBClusterParameters
QUERY PARAMS
DBClusterParameterGroupName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DescribeDBClusterParameters");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DescribeDBClusterParameters" {:query-params {:DBClusterParameterGroupName ""
                                                                                              :Action ""
                                                                                              :Version ""}})
require "http/client"

url = "{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DescribeDBClusterParameters"

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}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DescribeDBClusterParameters"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DescribeDBClusterParameters");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DescribeDBClusterParameters"

	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/?DBClusterParameterGroupName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DescribeDBClusterParameters")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DescribeDBClusterParameters"))
    .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}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DescribeDBClusterParameters")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DescribeDBClusterParameters")
  .asString();
const 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}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DescribeDBClusterParameters');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DescribeDBClusterParameters',
  params: {DBClusterParameterGroupName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DescribeDBClusterParameters';
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}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DescribeDBClusterParameters',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DescribeDBClusterParameters")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?DBClusterParameterGroupName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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=DescribeDBClusterParameters',
  qs: {DBClusterParameterGroupName: '', 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=DescribeDBClusterParameters');

req.query({
  DBClusterParameterGroupName: '',
  Action: '',
  Version: ''
});

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=DescribeDBClusterParameters',
  params: {DBClusterParameterGroupName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DescribeDBClusterParameters';
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}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DescribeDBClusterParameters"]
                                                       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}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DescribeDBClusterParameters" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DescribeDBClusterParameters",
  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}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DescribeDBClusterParameters');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeDBClusterParameters');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'DBClusterParameterGroupName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeDBClusterParameters');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'DBClusterParameterGroupName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DescribeDBClusterParameters' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DescribeDBClusterParameters' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?DBClusterParameterGroupName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DescribeDBClusterParameters"

querystring = {"DBClusterParameterGroupName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeDBClusterParameters"

queryString <- list(
  DBClusterParameterGroupName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DescribeDBClusterParameters")

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['DBClusterParameterGroupName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DescribeDBClusterParameters";

    let querystring = [
        ("DBClusterParameterGroupName", ""),
        ("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}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DescribeDBClusterParameters'
http GET '{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DescribeDBClusterParameters'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DescribeDBClusterParameters'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=DescribeDBClusterParameters")! 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_DescribeDBClusterSnapshotAttributes
{{baseUrl}}/#Action=DescribeDBClusterSnapshotAttributes
QUERY PARAMS
DBClusterSnapshotIdentifier
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DescribeDBClusterSnapshotAttributes");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DescribeDBClusterSnapshotAttributes" {:query-params {:DBClusterSnapshotIdentifier ""
                                                                                                      :Action ""
                                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DescribeDBClusterSnapshotAttributes"

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}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DescribeDBClusterSnapshotAttributes"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DescribeDBClusterSnapshotAttributes");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DescribeDBClusterSnapshotAttributes"

	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/?DBClusterSnapshotIdentifier=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DescribeDBClusterSnapshotAttributes")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DescribeDBClusterSnapshotAttributes"))
    .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}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DescribeDBClusterSnapshotAttributes")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DescribeDBClusterSnapshotAttributes")
  .asString();
const 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}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DescribeDBClusterSnapshotAttributes');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DescribeDBClusterSnapshotAttributes',
  params: {DBClusterSnapshotIdentifier: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DescribeDBClusterSnapshotAttributes';
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}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DescribeDBClusterSnapshotAttributes',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DescribeDBClusterSnapshotAttributes")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?DBClusterSnapshotIdentifier=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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=DescribeDBClusterSnapshotAttributes',
  qs: {DBClusterSnapshotIdentifier: '', 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=DescribeDBClusterSnapshotAttributes');

req.query({
  DBClusterSnapshotIdentifier: '',
  Action: '',
  Version: ''
});

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=DescribeDBClusterSnapshotAttributes',
  params: {DBClusterSnapshotIdentifier: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DescribeDBClusterSnapshotAttributes';
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}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DescribeDBClusterSnapshotAttributes"]
                                                       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}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DescribeDBClusterSnapshotAttributes" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DescribeDBClusterSnapshotAttributes",
  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}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DescribeDBClusterSnapshotAttributes');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeDBClusterSnapshotAttributes');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'DBClusterSnapshotIdentifier' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeDBClusterSnapshotAttributes');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'DBClusterSnapshotIdentifier' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DescribeDBClusterSnapshotAttributes' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DescribeDBClusterSnapshotAttributes' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?DBClusterSnapshotIdentifier=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DescribeDBClusterSnapshotAttributes"

querystring = {"DBClusterSnapshotIdentifier":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeDBClusterSnapshotAttributes"

queryString <- list(
  DBClusterSnapshotIdentifier = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DescribeDBClusterSnapshotAttributes")

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['DBClusterSnapshotIdentifier'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DescribeDBClusterSnapshotAttributes";

    let querystring = [
        ("DBClusterSnapshotIdentifier", ""),
        ("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}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DescribeDBClusterSnapshotAttributes'
http GET '{{baseUrl}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DescribeDBClusterSnapshotAttributes'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DescribeDBClusterSnapshotAttributes'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBClusterSnapshotIdentifier=&Action=&Version=#Action=DescribeDBClusterSnapshotAttributes")! 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_DescribeDBClusterSnapshots
{{baseUrl}}/#Action=DescribeDBClusterSnapshots
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=DescribeDBClusterSnapshots");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DescribeDBClusterSnapshots" {:query-params {:Action ""
                                                                                             :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshots"

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=DescribeDBClusterSnapshots"),
};
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=DescribeDBClusterSnapshots");
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=DescribeDBClusterSnapshots"

	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=DescribeDBClusterSnapshots")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshots"))
    .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=DescribeDBClusterSnapshots")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshots")
  .asString();
const 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=DescribeDBClusterSnapshots');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DescribeDBClusterSnapshots',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshots';
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=DescribeDBClusterSnapshots',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshots")
  .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=DescribeDBClusterSnapshots',
  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=DescribeDBClusterSnapshots');

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=DescribeDBClusterSnapshots',
  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=DescribeDBClusterSnapshots';
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=DescribeDBClusterSnapshots"]
                                                       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=DescribeDBClusterSnapshots" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshots",
  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=DescribeDBClusterSnapshots');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeDBClusterSnapshots');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeDBClusterSnapshots');
$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=DescribeDBClusterSnapshots' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshots' -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=DescribeDBClusterSnapshots"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeDBClusterSnapshots"

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=DescribeDBClusterSnapshots")

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=DescribeDBClusterSnapshots";

    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=DescribeDBClusterSnapshots'
http GET '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshots'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshots'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshots")! 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_DescribeDBClusters
{{baseUrl}}/#Action=DescribeDBClusters
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=DescribeDBClusters");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DescribeDBClusters" {:query-params {:Action ""
                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusters"

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=DescribeDBClusters"),
};
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=DescribeDBClusters");
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=DescribeDBClusters"

	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=DescribeDBClusters")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusters"))
    .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=DescribeDBClusters")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusters")
  .asString();
const 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=DescribeDBClusters');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DescribeDBClusters',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusters';
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=DescribeDBClusters',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusters")
  .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=DescribeDBClusters',
  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=DescribeDBClusters');

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=DescribeDBClusters',
  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=DescribeDBClusters';
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=DescribeDBClusters"]
                                                       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=DescribeDBClusters" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusters",
  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=DescribeDBClusters');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeDBClusters');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeDBClusters');
$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=DescribeDBClusters' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusters' -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=DescribeDBClusters"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeDBClusters"

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=DescribeDBClusters")

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=DescribeDBClusters";

    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=DescribeDBClusters'
http GET '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusters'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusters'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusters")! 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_DescribeDBEngineVersions
{{baseUrl}}/#Action=DescribeDBEngineVersions
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=DescribeDBEngineVersions");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DescribeDBEngineVersions" {:query-params {:Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeDBEngineVersions"

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=DescribeDBEngineVersions"),
};
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=DescribeDBEngineVersions");
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=DescribeDBEngineVersions"

	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=DescribeDBEngineVersions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeDBEngineVersions"))
    .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=DescribeDBEngineVersions")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=DescribeDBEngineVersions")
  .asString();
const 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=DescribeDBEngineVersions');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DescribeDBEngineVersions',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeDBEngineVersions';
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=DescribeDBEngineVersions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeDBEngineVersions")
  .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=DescribeDBEngineVersions',
  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=DescribeDBEngineVersions');

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=DescribeDBEngineVersions',
  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=DescribeDBEngineVersions';
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=DescribeDBEngineVersions"]
                                                       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=DescribeDBEngineVersions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeDBEngineVersions",
  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=DescribeDBEngineVersions');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeDBEngineVersions');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeDBEngineVersions');
$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=DescribeDBEngineVersions' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeDBEngineVersions' -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=DescribeDBEngineVersions"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeDBEngineVersions"

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=DescribeDBEngineVersions")

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=DescribeDBEngineVersions";

    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=DescribeDBEngineVersions'
http GET '{{baseUrl}}/?Action=&Version=#Action=DescribeDBEngineVersions'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeDBEngineVersions'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeDBEngineVersions")! 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_DescribeDBInstances
{{baseUrl}}/#Action=DescribeDBInstances
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=DescribeDBInstances");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DescribeDBInstances" {:query-params {:Action ""
                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeDBInstances"

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=DescribeDBInstances"),
};
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=DescribeDBInstances");
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=DescribeDBInstances"

	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=DescribeDBInstances")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeDBInstances"))
    .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=DescribeDBInstances")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=DescribeDBInstances")
  .asString();
const 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=DescribeDBInstances');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DescribeDBInstances',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeDBInstances';
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=DescribeDBInstances',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeDBInstances")
  .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=DescribeDBInstances',
  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=DescribeDBInstances');

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=DescribeDBInstances',
  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=DescribeDBInstances';
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=DescribeDBInstances"]
                                                       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=DescribeDBInstances" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeDBInstances",
  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=DescribeDBInstances');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeDBInstances');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeDBInstances');
$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=DescribeDBInstances' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeDBInstances' -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=DescribeDBInstances"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeDBInstances"

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=DescribeDBInstances")

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=DescribeDBInstances";

    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=DescribeDBInstances'
http GET '{{baseUrl}}/?Action=&Version=#Action=DescribeDBInstances'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeDBInstances'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeDBInstances")! 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_DescribeDBParameterGroups
{{baseUrl}}/#Action=DescribeDBParameterGroups
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=DescribeDBParameterGroups");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DescribeDBParameterGroups" {:query-params {:Action ""
                                                                                            :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameterGroups"

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=DescribeDBParameterGroups"),
};
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=DescribeDBParameterGroups");
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=DescribeDBParameterGroups"

	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=DescribeDBParameterGroups")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameterGroups"))
    .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=DescribeDBParameterGroups")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameterGroups")
  .asString();
const 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=DescribeDBParameterGroups');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DescribeDBParameterGroups',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameterGroups';
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=DescribeDBParameterGroups',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameterGroups")
  .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=DescribeDBParameterGroups',
  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=DescribeDBParameterGroups');

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=DescribeDBParameterGroups',
  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=DescribeDBParameterGroups';
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=DescribeDBParameterGroups"]
                                                       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=DescribeDBParameterGroups" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameterGroups",
  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=DescribeDBParameterGroups');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeDBParameterGroups');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeDBParameterGroups');
$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=DescribeDBParameterGroups' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameterGroups' -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=DescribeDBParameterGroups"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeDBParameterGroups"

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=DescribeDBParameterGroups")

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=DescribeDBParameterGroups";

    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=DescribeDBParameterGroups'
http GET '{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameterGroups'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameterGroups'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameterGroups")! 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_DescribeDBParameters
{{baseUrl}}/#Action=DescribeDBParameters
QUERY PARAMS
DBParameterGroupName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=DescribeDBParameters");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DescribeDBParameters" {:query-params {:DBParameterGroupName ""
                                                                                       :Action ""
                                                                                       :Version ""}})
require "http/client"

url = "{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=DescribeDBParameters"

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}}/?DBParameterGroupName=&Action=&Version=#Action=DescribeDBParameters"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=DescribeDBParameters");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=DescribeDBParameters"

	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/?DBParameterGroupName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=DescribeDBParameters")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=DescribeDBParameters"))
    .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}}/?DBParameterGroupName=&Action=&Version=#Action=DescribeDBParameters")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=DescribeDBParameters")
  .asString();
const 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}}/?DBParameterGroupName=&Action=&Version=#Action=DescribeDBParameters');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DescribeDBParameters',
  params: {DBParameterGroupName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=DescribeDBParameters';
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}}/?DBParameterGroupName=&Action=&Version=#Action=DescribeDBParameters',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=DescribeDBParameters")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?DBParameterGroupName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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=DescribeDBParameters',
  qs: {DBParameterGroupName: '', 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=DescribeDBParameters');

req.query({
  DBParameterGroupName: '',
  Action: '',
  Version: ''
});

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=DescribeDBParameters',
  params: {DBParameterGroupName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=DescribeDBParameters';
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}}/?DBParameterGroupName=&Action=&Version=#Action=DescribeDBParameters"]
                                                       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}}/?DBParameterGroupName=&Action=&Version=#Action=DescribeDBParameters" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=DescribeDBParameters",
  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}}/?DBParameterGroupName=&Action=&Version=#Action=DescribeDBParameters');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeDBParameters');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'DBParameterGroupName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeDBParameters');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'DBParameterGroupName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=DescribeDBParameters' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=DescribeDBParameters' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?DBParameterGroupName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DescribeDBParameters"

querystring = {"DBParameterGroupName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeDBParameters"

queryString <- list(
  DBParameterGroupName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=DescribeDBParameters")

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['DBParameterGroupName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DescribeDBParameters";

    let querystring = [
        ("DBParameterGroupName", ""),
        ("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}}/?DBParameterGroupName=&Action=&Version=#Action=DescribeDBParameters'
http GET '{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=DescribeDBParameters'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=DescribeDBParameters'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=DescribeDBParameters")! 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_DescribeDBSubnetGroups
{{baseUrl}}/#Action=DescribeDBSubnetGroups
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=DescribeDBSubnetGroups");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DescribeDBSubnetGroups" {:query-params {:Action ""
                                                                                         :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeDBSubnetGroups"

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=DescribeDBSubnetGroups"),
};
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=DescribeDBSubnetGroups");
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=DescribeDBSubnetGroups"

	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=DescribeDBSubnetGroups")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeDBSubnetGroups"))
    .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=DescribeDBSubnetGroups")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=DescribeDBSubnetGroups")
  .asString();
const 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=DescribeDBSubnetGroups');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DescribeDBSubnetGroups',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeDBSubnetGroups';
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=DescribeDBSubnetGroups',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeDBSubnetGroups")
  .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=DescribeDBSubnetGroups',
  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=DescribeDBSubnetGroups');

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=DescribeDBSubnetGroups',
  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=DescribeDBSubnetGroups';
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=DescribeDBSubnetGroups"]
                                                       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=DescribeDBSubnetGroups" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeDBSubnetGroups",
  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=DescribeDBSubnetGroups');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeDBSubnetGroups');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeDBSubnetGroups');
$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=DescribeDBSubnetGroups' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeDBSubnetGroups' -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=DescribeDBSubnetGroups"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeDBSubnetGroups"

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=DescribeDBSubnetGroups")

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=DescribeDBSubnetGroups";

    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=DescribeDBSubnetGroups'
http GET '{{baseUrl}}/?Action=&Version=#Action=DescribeDBSubnetGroups'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeDBSubnetGroups'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeDBSubnetGroups")! 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_DescribeEngineDefaultClusterParameters
{{baseUrl}}/#Action=DescribeEngineDefaultClusterParameters
QUERY PARAMS
DBParameterGroupFamily
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultClusterParameters");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DescribeEngineDefaultClusterParameters" {:query-params {:DBParameterGroupFamily ""
                                                                                                         :Action ""
                                                                                                         :Version ""}})
require "http/client"

url = "{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultClusterParameters"

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}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultClusterParameters"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultClusterParameters");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultClusterParameters"

	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/?DBParameterGroupFamily=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultClusterParameters")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultClusterParameters"))
    .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}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultClusterParameters")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultClusterParameters")
  .asString();
const 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}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultClusterParameters');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DescribeEngineDefaultClusterParameters',
  params: {DBParameterGroupFamily: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultClusterParameters';
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}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultClusterParameters',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultClusterParameters")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?DBParameterGroupFamily=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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=DescribeEngineDefaultClusterParameters',
  qs: {DBParameterGroupFamily: '', 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=DescribeEngineDefaultClusterParameters');

req.query({
  DBParameterGroupFamily: '',
  Action: '',
  Version: ''
});

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=DescribeEngineDefaultClusterParameters',
  params: {DBParameterGroupFamily: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultClusterParameters';
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}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultClusterParameters"]
                                                       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}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultClusterParameters" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultClusterParameters",
  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}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultClusterParameters');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeEngineDefaultClusterParameters');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'DBParameterGroupFamily' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeEngineDefaultClusterParameters');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'DBParameterGroupFamily' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultClusterParameters' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultClusterParameters' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?DBParameterGroupFamily=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DescribeEngineDefaultClusterParameters"

querystring = {"DBParameterGroupFamily":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeEngineDefaultClusterParameters"

queryString <- list(
  DBParameterGroupFamily = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultClusterParameters")

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['DBParameterGroupFamily'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DescribeEngineDefaultClusterParameters";

    let querystring = [
        ("DBParameterGroupFamily", ""),
        ("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}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultClusterParameters'
http GET '{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultClusterParameters'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultClusterParameters'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultClusterParameters")! 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_DescribeEngineDefaultParameters
{{baseUrl}}/#Action=DescribeEngineDefaultParameters
QUERY PARAMS
DBParameterGroupFamily
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultParameters");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DescribeEngineDefaultParameters" {:query-params {:DBParameterGroupFamily ""
                                                                                                  :Action ""
                                                                                                  :Version ""}})
require "http/client"

url = "{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultParameters"

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}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultParameters"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultParameters");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultParameters"

	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/?DBParameterGroupFamily=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultParameters")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultParameters"))
    .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}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultParameters")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultParameters")
  .asString();
const 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}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultParameters');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DescribeEngineDefaultParameters',
  params: {DBParameterGroupFamily: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultParameters';
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}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultParameters',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultParameters")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?DBParameterGroupFamily=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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=DescribeEngineDefaultParameters',
  qs: {DBParameterGroupFamily: '', 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=DescribeEngineDefaultParameters');

req.query({
  DBParameterGroupFamily: '',
  Action: '',
  Version: ''
});

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=DescribeEngineDefaultParameters',
  params: {DBParameterGroupFamily: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultParameters';
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}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultParameters"]
                                                       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}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultParameters" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultParameters",
  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}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultParameters');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeEngineDefaultParameters');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'DBParameterGroupFamily' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeEngineDefaultParameters');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'DBParameterGroupFamily' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultParameters' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultParameters' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?DBParameterGroupFamily=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DescribeEngineDefaultParameters"

querystring = {"DBParameterGroupFamily":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeEngineDefaultParameters"

queryString <- list(
  DBParameterGroupFamily = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultParameters")

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['DBParameterGroupFamily'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DescribeEngineDefaultParameters";

    let querystring = [
        ("DBParameterGroupFamily", ""),
        ("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}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultParameters'
http GET '{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultParameters'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultParameters'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBParameterGroupFamily=&Action=&Version=#Action=DescribeEngineDefaultParameters")! 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_DescribeEventCategories
{{baseUrl}}/#Action=DescribeEventCategories
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=DescribeEventCategories");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DescribeEventCategories" {:query-params {:Action ""
                                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeEventCategories"

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=DescribeEventCategories"),
};
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=DescribeEventCategories");
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=DescribeEventCategories"

	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=DescribeEventCategories")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeEventCategories"))
    .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=DescribeEventCategories")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=DescribeEventCategories")
  .asString();
const 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=DescribeEventCategories');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DescribeEventCategories',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeEventCategories';
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=DescribeEventCategories',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeEventCategories")
  .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=DescribeEventCategories',
  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=DescribeEventCategories');

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=DescribeEventCategories',
  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=DescribeEventCategories';
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=DescribeEventCategories"]
                                                       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=DescribeEventCategories" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeEventCategories",
  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=DescribeEventCategories');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeEventCategories');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeEventCategories');
$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=DescribeEventCategories' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeEventCategories' -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=DescribeEventCategories"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeEventCategories"

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=DescribeEventCategories")

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=DescribeEventCategories";

    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=DescribeEventCategories'
http GET '{{baseUrl}}/?Action=&Version=#Action=DescribeEventCategories'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeEventCategories'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeEventCategories")! 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_DescribeEventSubscriptions
{{baseUrl}}/#Action=DescribeEventSubscriptions
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=DescribeEventSubscriptions");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DescribeEventSubscriptions" {:query-params {:Action ""
                                                                                             :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeEventSubscriptions"

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=DescribeEventSubscriptions"),
};
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=DescribeEventSubscriptions");
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=DescribeEventSubscriptions"

	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=DescribeEventSubscriptions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeEventSubscriptions"))
    .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=DescribeEventSubscriptions")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=DescribeEventSubscriptions")
  .asString();
const 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=DescribeEventSubscriptions');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DescribeEventSubscriptions',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeEventSubscriptions';
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=DescribeEventSubscriptions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeEventSubscriptions")
  .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=DescribeEventSubscriptions',
  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=DescribeEventSubscriptions');

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=DescribeEventSubscriptions',
  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=DescribeEventSubscriptions';
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=DescribeEventSubscriptions"]
                                                       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=DescribeEventSubscriptions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeEventSubscriptions",
  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=DescribeEventSubscriptions');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeEventSubscriptions');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeEventSubscriptions');
$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=DescribeEventSubscriptions' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeEventSubscriptions' -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=DescribeEventSubscriptions"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeEventSubscriptions"

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=DescribeEventSubscriptions")

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=DescribeEventSubscriptions";

    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=DescribeEventSubscriptions'
http GET '{{baseUrl}}/?Action=&Version=#Action=DescribeEventSubscriptions'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeEventSubscriptions'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeEventSubscriptions")! 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_DescribeEvents
{{baseUrl}}/#Action=DescribeEvents
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=DescribeEvents");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DescribeEvents" {:query-params {:Action ""
                                                                                 :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeEvents"

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=DescribeEvents"),
};
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=DescribeEvents");
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=DescribeEvents"

	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=DescribeEvents")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeEvents"))
    .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=DescribeEvents")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=DescribeEvents")
  .asString();
const 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=DescribeEvents');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DescribeEvents',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeEvents';
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=DescribeEvents',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeEvents")
  .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=DescribeEvents',
  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=DescribeEvents');

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=DescribeEvents',
  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=DescribeEvents';
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=DescribeEvents"]
                                                       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=DescribeEvents" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeEvents",
  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=DescribeEvents');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeEvents');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeEvents');
$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=DescribeEvents' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeEvents' -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=DescribeEvents"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeEvents"

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=DescribeEvents")

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=DescribeEvents";

    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=DescribeEvents'
http GET '{{baseUrl}}/?Action=&Version=#Action=DescribeEvents'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeEvents'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeEvents")! 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_DescribeGlobalClusters
{{baseUrl}}/#Action=DescribeGlobalClusters
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=DescribeGlobalClusters");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DescribeGlobalClusters" {:query-params {:Action ""
                                                                                         :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeGlobalClusters"

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=DescribeGlobalClusters"),
};
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=DescribeGlobalClusters");
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=DescribeGlobalClusters"

	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=DescribeGlobalClusters")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeGlobalClusters"))
    .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=DescribeGlobalClusters")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=DescribeGlobalClusters")
  .asString();
const 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=DescribeGlobalClusters');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DescribeGlobalClusters',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeGlobalClusters';
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=DescribeGlobalClusters',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeGlobalClusters")
  .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=DescribeGlobalClusters',
  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=DescribeGlobalClusters');

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=DescribeGlobalClusters',
  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=DescribeGlobalClusters';
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=DescribeGlobalClusters"]
                                                       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=DescribeGlobalClusters" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeGlobalClusters",
  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=DescribeGlobalClusters');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeGlobalClusters');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeGlobalClusters');
$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=DescribeGlobalClusters' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeGlobalClusters' -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=DescribeGlobalClusters"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeGlobalClusters"

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=DescribeGlobalClusters")

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=DescribeGlobalClusters";

    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=DescribeGlobalClusters'
http GET '{{baseUrl}}/?Action=&Version=#Action=DescribeGlobalClusters'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeGlobalClusters'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeGlobalClusters")! 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_DescribeOrderableDBInstanceOptions
{{baseUrl}}/#Action=DescribeOrderableDBInstanceOptions
QUERY PARAMS
Engine
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?Engine=&Action=&Version=#Action=DescribeOrderableDBInstanceOptions");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DescribeOrderableDBInstanceOptions" {:query-params {:Engine ""
                                                                                                     :Action ""
                                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Engine=&Action=&Version=#Action=DescribeOrderableDBInstanceOptions"

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}}/?Engine=&Action=&Version=#Action=DescribeOrderableDBInstanceOptions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?Engine=&Action=&Version=#Action=DescribeOrderableDBInstanceOptions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?Engine=&Action=&Version=#Action=DescribeOrderableDBInstanceOptions"

	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/?Engine=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?Engine=&Action=&Version=#Action=DescribeOrderableDBInstanceOptions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Engine=&Action=&Version=#Action=DescribeOrderableDBInstanceOptions"))
    .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}}/?Engine=&Action=&Version=#Action=DescribeOrderableDBInstanceOptions")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Engine=&Action=&Version=#Action=DescribeOrderableDBInstanceOptions")
  .asString();
const 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}}/?Engine=&Action=&Version=#Action=DescribeOrderableDBInstanceOptions');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DescribeOrderableDBInstanceOptions',
  params: {Engine: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Engine=&Action=&Version=#Action=DescribeOrderableDBInstanceOptions';
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}}/?Engine=&Action=&Version=#Action=DescribeOrderableDBInstanceOptions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Engine=&Action=&Version=#Action=DescribeOrderableDBInstanceOptions")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?Engine=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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=DescribeOrderableDBInstanceOptions',
  qs: {Engine: '', 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=DescribeOrderableDBInstanceOptions');

req.query({
  Engine: '',
  Action: '',
  Version: ''
});

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=DescribeOrderableDBInstanceOptions',
  params: {Engine: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?Engine=&Action=&Version=#Action=DescribeOrderableDBInstanceOptions';
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}}/?Engine=&Action=&Version=#Action=DescribeOrderableDBInstanceOptions"]
                                                       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}}/?Engine=&Action=&Version=#Action=DescribeOrderableDBInstanceOptions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Engine=&Action=&Version=#Action=DescribeOrderableDBInstanceOptions",
  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}}/?Engine=&Action=&Version=#Action=DescribeOrderableDBInstanceOptions');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeOrderableDBInstanceOptions');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Engine' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeOrderableDBInstanceOptions');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Engine' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?Engine=&Action=&Version=#Action=DescribeOrderableDBInstanceOptions' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Engine=&Action=&Version=#Action=DescribeOrderableDBInstanceOptions' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?Engine=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DescribeOrderableDBInstanceOptions"

querystring = {"Engine":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeOrderableDBInstanceOptions"

queryString <- list(
  Engine = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?Engine=&Action=&Version=#Action=DescribeOrderableDBInstanceOptions")

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['Engine'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DescribeOrderableDBInstanceOptions";

    let querystring = [
        ("Engine", ""),
        ("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}}/?Engine=&Action=&Version=#Action=DescribeOrderableDBInstanceOptions'
http GET '{{baseUrl}}/?Engine=&Action=&Version=#Action=DescribeOrderableDBInstanceOptions'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Engine=&Action=&Version=#Action=DescribeOrderableDBInstanceOptions'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Engine=&Action=&Version=#Action=DescribeOrderableDBInstanceOptions")! 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_DescribePendingMaintenanceActions
{{baseUrl}}/#Action=DescribePendingMaintenanceActions
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=DescribePendingMaintenanceActions");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DescribePendingMaintenanceActions" {:query-params {:Action ""
                                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribePendingMaintenanceActions"

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=DescribePendingMaintenanceActions"),
};
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=DescribePendingMaintenanceActions");
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=DescribePendingMaintenanceActions"

	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=DescribePendingMaintenanceActions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribePendingMaintenanceActions"))
    .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=DescribePendingMaintenanceActions")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=DescribePendingMaintenanceActions")
  .asString();
const 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=DescribePendingMaintenanceActions');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DescribePendingMaintenanceActions',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribePendingMaintenanceActions';
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=DescribePendingMaintenanceActions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribePendingMaintenanceActions")
  .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=DescribePendingMaintenanceActions',
  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=DescribePendingMaintenanceActions');

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=DescribePendingMaintenanceActions',
  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=DescribePendingMaintenanceActions';
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=DescribePendingMaintenanceActions"]
                                                       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=DescribePendingMaintenanceActions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribePendingMaintenanceActions",
  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=DescribePendingMaintenanceActions');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribePendingMaintenanceActions');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribePendingMaintenanceActions');
$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=DescribePendingMaintenanceActions' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribePendingMaintenanceActions' -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=DescribePendingMaintenanceActions"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribePendingMaintenanceActions"

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=DescribePendingMaintenanceActions")

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=DescribePendingMaintenanceActions";

    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=DescribePendingMaintenanceActions'
http GET '{{baseUrl}}/?Action=&Version=#Action=DescribePendingMaintenanceActions'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribePendingMaintenanceActions'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribePendingMaintenanceActions")! 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_DescribeValidDBInstanceModifications
{{baseUrl}}/#Action=DescribeValidDBInstanceModifications
QUERY PARAMS
DBInstanceIdentifier
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=DescribeValidDBInstanceModifications");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=DescribeValidDBInstanceModifications" {:query-params {:DBInstanceIdentifier ""
                                                                                                       :Action ""
                                                                                                       :Version ""}})
require "http/client"

url = "{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=DescribeValidDBInstanceModifications"

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}}/?DBInstanceIdentifier=&Action=&Version=#Action=DescribeValidDBInstanceModifications"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=DescribeValidDBInstanceModifications");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=DescribeValidDBInstanceModifications"

	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/?DBInstanceIdentifier=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=DescribeValidDBInstanceModifications")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=DescribeValidDBInstanceModifications"))
    .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}}/?DBInstanceIdentifier=&Action=&Version=#Action=DescribeValidDBInstanceModifications")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=DescribeValidDBInstanceModifications")
  .asString();
const 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}}/?DBInstanceIdentifier=&Action=&Version=#Action=DescribeValidDBInstanceModifications');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=DescribeValidDBInstanceModifications',
  params: {DBInstanceIdentifier: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=DescribeValidDBInstanceModifications';
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}}/?DBInstanceIdentifier=&Action=&Version=#Action=DescribeValidDBInstanceModifications',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=DescribeValidDBInstanceModifications")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?DBInstanceIdentifier=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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=DescribeValidDBInstanceModifications',
  qs: {DBInstanceIdentifier: '', 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=DescribeValidDBInstanceModifications');

req.query({
  DBInstanceIdentifier: '',
  Action: '',
  Version: ''
});

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=DescribeValidDBInstanceModifications',
  params: {DBInstanceIdentifier: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=DescribeValidDBInstanceModifications';
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}}/?DBInstanceIdentifier=&Action=&Version=#Action=DescribeValidDBInstanceModifications"]
                                                       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}}/?DBInstanceIdentifier=&Action=&Version=#Action=DescribeValidDBInstanceModifications" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=DescribeValidDBInstanceModifications",
  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}}/?DBInstanceIdentifier=&Action=&Version=#Action=DescribeValidDBInstanceModifications');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeValidDBInstanceModifications');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'DBInstanceIdentifier' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeValidDBInstanceModifications');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'DBInstanceIdentifier' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=DescribeValidDBInstanceModifications' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=DescribeValidDBInstanceModifications' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?DBInstanceIdentifier=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=DescribeValidDBInstanceModifications"

querystring = {"DBInstanceIdentifier":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeValidDBInstanceModifications"

queryString <- list(
  DBInstanceIdentifier = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=DescribeValidDBInstanceModifications")

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['DBInstanceIdentifier'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=DescribeValidDBInstanceModifications";

    let querystring = [
        ("DBInstanceIdentifier", ""),
        ("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}}/?DBInstanceIdentifier=&Action=&Version=#Action=DescribeValidDBInstanceModifications'
http GET '{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=DescribeValidDBInstanceModifications'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=DescribeValidDBInstanceModifications'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=DescribeValidDBInstanceModifications")! 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_FailoverDBCluster
{{baseUrl}}/#Action=FailoverDBCluster
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=FailoverDBCluster");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=FailoverDBCluster" {:query-params {:Action ""
                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=FailoverDBCluster"

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=FailoverDBCluster"),
};
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=FailoverDBCluster");
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=FailoverDBCluster"

	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=FailoverDBCluster")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=FailoverDBCluster"))
    .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=FailoverDBCluster")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?Action=&Version=#Action=FailoverDBCluster")
  .asString();
const 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=FailoverDBCluster');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=FailoverDBCluster',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=FailoverDBCluster';
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=FailoverDBCluster',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=FailoverDBCluster")
  .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=FailoverDBCluster',
  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=FailoverDBCluster');

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=FailoverDBCluster',
  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=FailoverDBCluster';
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=FailoverDBCluster"]
                                                       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=FailoverDBCluster" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=FailoverDBCluster",
  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=FailoverDBCluster');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=FailoverDBCluster');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=FailoverDBCluster');
$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=FailoverDBCluster' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=FailoverDBCluster' -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=FailoverDBCluster"

querystring = {"Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=FailoverDBCluster"

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=FailoverDBCluster")

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=FailoverDBCluster";

    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=FailoverDBCluster'
http GET '{{baseUrl}}/?Action=&Version=#Action=FailoverDBCluster'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=FailoverDBCluster'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=FailoverDBCluster")! 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_FailoverGlobalCluster
{{baseUrl}}/#Action=FailoverGlobalCluster
QUERY PARAMS
GlobalClusterIdentifier
TargetDbClusterIdentifier
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?GlobalClusterIdentifier=&TargetDbClusterIdentifier=&Action=&Version=#Action=FailoverGlobalCluster");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=FailoverGlobalCluster" {:query-params {:GlobalClusterIdentifier ""
                                                                                        :TargetDbClusterIdentifier ""
                                                                                        :Action ""
                                                                                        :Version ""}})
require "http/client"

url = "{{baseUrl}}/?GlobalClusterIdentifier=&TargetDbClusterIdentifier=&Action=&Version=#Action=FailoverGlobalCluster"

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}}/?GlobalClusterIdentifier=&TargetDbClusterIdentifier=&Action=&Version=#Action=FailoverGlobalCluster"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?GlobalClusterIdentifier=&TargetDbClusterIdentifier=&Action=&Version=#Action=FailoverGlobalCluster");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?GlobalClusterIdentifier=&TargetDbClusterIdentifier=&Action=&Version=#Action=FailoverGlobalCluster"

	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/?GlobalClusterIdentifier=&TargetDbClusterIdentifier=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?GlobalClusterIdentifier=&TargetDbClusterIdentifier=&Action=&Version=#Action=FailoverGlobalCluster")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?GlobalClusterIdentifier=&TargetDbClusterIdentifier=&Action=&Version=#Action=FailoverGlobalCluster"))
    .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}}/?GlobalClusterIdentifier=&TargetDbClusterIdentifier=&Action=&Version=#Action=FailoverGlobalCluster")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?GlobalClusterIdentifier=&TargetDbClusterIdentifier=&Action=&Version=#Action=FailoverGlobalCluster")
  .asString();
const 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}}/?GlobalClusterIdentifier=&TargetDbClusterIdentifier=&Action=&Version=#Action=FailoverGlobalCluster');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=FailoverGlobalCluster',
  params: {
    GlobalClusterIdentifier: '',
    TargetDbClusterIdentifier: '',
    Action: '',
    Version: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?GlobalClusterIdentifier=&TargetDbClusterIdentifier=&Action=&Version=#Action=FailoverGlobalCluster';
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}}/?GlobalClusterIdentifier=&TargetDbClusterIdentifier=&Action=&Version=#Action=FailoverGlobalCluster',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?GlobalClusterIdentifier=&TargetDbClusterIdentifier=&Action=&Version=#Action=FailoverGlobalCluster")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?GlobalClusterIdentifier=&TargetDbClusterIdentifier=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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=FailoverGlobalCluster',
  qs: {
    GlobalClusterIdentifier: '',
    TargetDbClusterIdentifier: '',
    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=FailoverGlobalCluster');

req.query({
  GlobalClusterIdentifier: '',
  TargetDbClusterIdentifier: '',
  Action: '',
  Version: ''
});

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=FailoverGlobalCluster',
  params: {
    GlobalClusterIdentifier: '',
    TargetDbClusterIdentifier: '',
    Action: '',
    Version: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?GlobalClusterIdentifier=&TargetDbClusterIdentifier=&Action=&Version=#Action=FailoverGlobalCluster';
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}}/?GlobalClusterIdentifier=&TargetDbClusterIdentifier=&Action=&Version=#Action=FailoverGlobalCluster"]
                                                       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}}/?GlobalClusterIdentifier=&TargetDbClusterIdentifier=&Action=&Version=#Action=FailoverGlobalCluster" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?GlobalClusterIdentifier=&TargetDbClusterIdentifier=&Action=&Version=#Action=FailoverGlobalCluster",
  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}}/?GlobalClusterIdentifier=&TargetDbClusterIdentifier=&Action=&Version=#Action=FailoverGlobalCluster');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=FailoverGlobalCluster');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'GlobalClusterIdentifier' => '',
  'TargetDbClusterIdentifier' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=FailoverGlobalCluster');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'GlobalClusterIdentifier' => '',
  'TargetDbClusterIdentifier' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?GlobalClusterIdentifier=&TargetDbClusterIdentifier=&Action=&Version=#Action=FailoverGlobalCluster' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?GlobalClusterIdentifier=&TargetDbClusterIdentifier=&Action=&Version=#Action=FailoverGlobalCluster' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?GlobalClusterIdentifier=&TargetDbClusterIdentifier=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=FailoverGlobalCluster"

querystring = {"GlobalClusterIdentifier":"","TargetDbClusterIdentifier":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=FailoverGlobalCluster"

queryString <- list(
  GlobalClusterIdentifier = "",
  TargetDbClusterIdentifier = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?GlobalClusterIdentifier=&TargetDbClusterIdentifier=&Action=&Version=#Action=FailoverGlobalCluster")

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['GlobalClusterIdentifier'] = ''
  req.params['TargetDbClusterIdentifier'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=FailoverGlobalCluster";

    let querystring = [
        ("GlobalClusterIdentifier", ""),
        ("TargetDbClusterIdentifier", ""),
        ("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}}/?GlobalClusterIdentifier=&TargetDbClusterIdentifier=&Action=&Version=#Action=FailoverGlobalCluster'
http GET '{{baseUrl}}/?GlobalClusterIdentifier=&TargetDbClusterIdentifier=&Action=&Version=#Action=FailoverGlobalCluster'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?GlobalClusterIdentifier=&TargetDbClusterIdentifier=&Action=&Version=#Action=FailoverGlobalCluster'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?GlobalClusterIdentifier=&TargetDbClusterIdentifier=&Action=&Version=#Action=FailoverGlobalCluster")! 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_ListTagsForResource
{{baseUrl}}/#Action=ListTagsForResource
QUERY PARAMS
ResourceName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?ResourceName=&Action=&Version=#Action=ListTagsForResource");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ListTagsForResource" {:query-params {:ResourceName ""
                                                                                      :Action ""
                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?ResourceName=&Action=&Version=#Action=ListTagsForResource"

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}}/?ResourceName=&Action=&Version=#Action=ListTagsForResource"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?ResourceName=&Action=&Version=#Action=ListTagsForResource");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?ResourceName=&Action=&Version=#Action=ListTagsForResource"

	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/?ResourceName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?ResourceName=&Action=&Version=#Action=ListTagsForResource")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?ResourceName=&Action=&Version=#Action=ListTagsForResource"))
    .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}}/?ResourceName=&Action=&Version=#Action=ListTagsForResource")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?ResourceName=&Action=&Version=#Action=ListTagsForResource")
  .asString();
const 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}}/?ResourceName=&Action=&Version=#Action=ListTagsForResource');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ListTagsForResource',
  params: {ResourceName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?ResourceName=&Action=&Version=#Action=ListTagsForResource';
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}}/?ResourceName=&Action=&Version=#Action=ListTagsForResource',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?ResourceName=&Action=&Version=#Action=ListTagsForResource")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?ResourceName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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=ListTagsForResource',
  qs: {ResourceName: '', 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=ListTagsForResource');

req.query({
  ResourceName: '',
  Action: '',
  Version: ''
});

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=ListTagsForResource',
  params: {ResourceName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?ResourceName=&Action=&Version=#Action=ListTagsForResource';
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}}/?ResourceName=&Action=&Version=#Action=ListTagsForResource"]
                                                       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}}/?ResourceName=&Action=&Version=#Action=ListTagsForResource" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?ResourceName=&Action=&Version=#Action=ListTagsForResource",
  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}}/?ResourceName=&Action=&Version=#Action=ListTagsForResource');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListTagsForResource');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'ResourceName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListTagsForResource');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'ResourceName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?ResourceName=&Action=&Version=#Action=ListTagsForResource' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?ResourceName=&Action=&Version=#Action=ListTagsForResource' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?ResourceName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ListTagsForResource"

querystring = {"ResourceName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListTagsForResource"

queryString <- list(
  ResourceName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?ResourceName=&Action=&Version=#Action=ListTagsForResource")

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['ResourceName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ListTagsForResource";

    let querystring = [
        ("ResourceName", ""),
        ("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}}/?ResourceName=&Action=&Version=#Action=ListTagsForResource'
http GET '{{baseUrl}}/?ResourceName=&Action=&Version=#Action=ListTagsForResource'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?ResourceName=&Action=&Version=#Action=ListTagsForResource'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?ResourceName=&Action=&Version=#Action=ListTagsForResource")! 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_ModifyDBCluster
{{baseUrl}}/#Action=ModifyDBCluster
QUERY PARAMS
DBClusterIdentifier
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=ModifyDBCluster");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ModifyDBCluster" {:query-params {:DBClusterIdentifier ""
                                                                                  :Action ""
                                                                                  :Version ""}})
require "http/client"

url = "{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=ModifyDBCluster"

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}}/?DBClusterIdentifier=&Action=&Version=#Action=ModifyDBCluster"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=ModifyDBCluster");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=ModifyDBCluster"

	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/?DBClusterIdentifier=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=ModifyDBCluster")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=ModifyDBCluster"))
    .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}}/?DBClusterIdentifier=&Action=&Version=#Action=ModifyDBCluster")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=ModifyDBCluster")
  .asString();
const 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}}/?DBClusterIdentifier=&Action=&Version=#Action=ModifyDBCluster');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ModifyDBCluster',
  params: {DBClusterIdentifier: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=ModifyDBCluster';
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}}/?DBClusterIdentifier=&Action=&Version=#Action=ModifyDBCluster',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=ModifyDBCluster")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?DBClusterIdentifier=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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=ModifyDBCluster',
  qs: {DBClusterIdentifier: '', 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=ModifyDBCluster');

req.query({
  DBClusterIdentifier: '',
  Action: '',
  Version: ''
});

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=ModifyDBCluster',
  params: {DBClusterIdentifier: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=ModifyDBCluster';
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}}/?DBClusterIdentifier=&Action=&Version=#Action=ModifyDBCluster"]
                                                       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}}/?DBClusterIdentifier=&Action=&Version=#Action=ModifyDBCluster" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=ModifyDBCluster",
  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}}/?DBClusterIdentifier=&Action=&Version=#Action=ModifyDBCluster');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ModifyDBCluster');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'DBClusterIdentifier' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ModifyDBCluster');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'DBClusterIdentifier' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=ModifyDBCluster' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=ModifyDBCluster' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?DBClusterIdentifier=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ModifyDBCluster"

querystring = {"DBClusterIdentifier":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ModifyDBCluster"

queryString <- list(
  DBClusterIdentifier = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=ModifyDBCluster")

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['DBClusterIdentifier'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ModifyDBCluster";

    let querystring = [
        ("DBClusterIdentifier", ""),
        ("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}}/?DBClusterIdentifier=&Action=&Version=#Action=ModifyDBCluster'
http GET '{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=ModifyDBCluster'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=ModifyDBCluster'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=ModifyDBCluster")! 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_ModifyDBClusterEndpoint
{{baseUrl}}/#Action=ModifyDBClusterEndpoint
QUERY PARAMS
DBClusterEndpointIdentifier
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=ModifyDBClusterEndpoint");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ModifyDBClusterEndpoint" {:query-params {:DBClusterEndpointIdentifier ""
                                                                                          :Action ""
                                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=ModifyDBClusterEndpoint"

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}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=ModifyDBClusterEndpoint"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=ModifyDBClusterEndpoint");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=ModifyDBClusterEndpoint"

	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/?DBClusterEndpointIdentifier=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=ModifyDBClusterEndpoint")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=ModifyDBClusterEndpoint"))
    .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}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=ModifyDBClusterEndpoint")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=ModifyDBClusterEndpoint")
  .asString();
const 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}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=ModifyDBClusterEndpoint');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ModifyDBClusterEndpoint',
  params: {DBClusterEndpointIdentifier: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=ModifyDBClusterEndpoint';
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}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=ModifyDBClusterEndpoint',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=ModifyDBClusterEndpoint")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?DBClusterEndpointIdentifier=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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=ModifyDBClusterEndpoint',
  qs: {DBClusterEndpointIdentifier: '', 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=ModifyDBClusterEndpoint');

req.query({
  DBClusterEndpointIdentifier: '',
  Action: '',
  Version: ''
});

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=ModifyDBClusterEndpoint',
  params: {DBClusterEndpointIdentifier: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=ModifyDBClusterEndpoint';
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}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=ModifyDBClusterEndpoint"]
                                                       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}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=ModifyDBClusterEndpoint" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=ModifyDBClusterEndpoint",
  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}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=ModifyDBClusterEndpoint');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ModifyDBClusterEndpoint');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'DBClusterEndpointIdentifier' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ModifyDBClusterEndpoint');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'DBClusterEndpointIdentifier' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=ModifyDBClusterEndpoint' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=ModifyDBClusterEndpoint' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?DBClusterEndpointIdentifier=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ModifyDBClusterEndpoint"

querystring = {"DBClusterEndpointIdentifier":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ModifyDBClusterEndpoint"

queryString <- list(
  DBClusterEndpointIdentifier = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=ModifyDBClusterEndpoint")

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['DBClusterEndpointIdentifier'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ModifyDBClusterEndpoint";

    let querystring = [
        ("DBClusterEndpointIdentifier", ""),
        ("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}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=ModifyDBClusterEndpoint'
http GET '{{baseUrl}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=ModifyDBClusterEndpoint'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=ModifyDBClusterEndpoint'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBClusterEndpointIdentifier=&Action=&Version=#Action=ModifyDBClusterEndpoint")! 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_ModifyDBClusterParameterGroup
{{baseUrl}}/#Action=ModifyDBClusterParameterGroup
QUERY PARAMS
DBClusterParameterGroupName
Parameters
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?DBClusterParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBClusterParameterGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ModifyDBClusterParameterGroup" {:query-params {:DBClusterParameterGroupName ""
                                                                                                :Parameters ""
                                                                                                :Action ""
                                                                                                :Version ""}})
require "http/client"

url = "{{baseUrl}}/?DBClusterParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBClusterParameterGroup"

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}}/?DBClusterParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBClusterParameterGroup"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBClusterParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBClusterParameterGroup");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?DBClusterParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBClusterParameterGroup"

	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/?DBClusterParameterGroupName=&Parameters=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?DBClusterParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBClusterParameterGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBClusterParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBClusterParameterGroup"))
    .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}}/?DBClusterParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBClusterParameterGroup")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBClusterParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBClusterParameterGroup")
  .asString();
const 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}}/?DBClusterParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBClusterParameterGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ModifyDBClusterParameterGroup',
  params: {DBClusterParameterGroupName: '', Parameters: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBClusterParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBClusterParameterGroup';
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}}/?DBClusterParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBClusterParameterGroup',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?DBClusterParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBClusterParameterGroup")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?DBClusterParameterGroupName=&Parameters=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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=ModifyDBClusterParameterGroup',
  qs: {DBClusterParameterGroupName: '', Parameters: '', 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=ModifyDBClusterParameterGroup');

req.query({
  DBClusterParameterGroupName: '',
  Parameters: '',
  Action: '',
  Version: ''
});

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=ModifyDBClusterParameterGroup',
  params: {DBClusterParameterGroupName: '', Parameters: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?DBClusterParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBClusterParameterGroup';
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}}/?DBClusterParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBClusterParameterGroup"]
                                                       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}}/?DBClusterParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBClusterParameterGroup" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBClusterParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBClusterParameterGroup",
  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}}/?DBClusterParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBClusterParameterGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ModifyDBClusterParameterGroup');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'DBClusterParameterGroupName' => '',
  'Parameters' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ModifyDBClusterParameterGroup');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'DBClusterParameterGroupName' => '',
  'Parameters' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?DBClusterParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBClusterParameterGroup' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?DBClusterParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBClusterParameterGroup' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?DBClusterParameterGroupName=&Parameters=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ModifyDBClusterParameterGroup"

querystring = {"DBClusterParameterGroupName":"","Parameters":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ModifyDBClusterParameterGroup"

queryString <- list(
  DBClusterParameterGroupName = "",
  Parameters = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?DBClusterParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBClusterParameterGroup")

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['DBClusterParameterGroupName'] = ''
  req.params['Parameters'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ModifyDBClusterParameterGroup";

    let querystring = [
        ("DBClusterParameterGroupName", ""),
        ("Parameters", ""),
        ("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}}/?DBClusterParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBClusterParameterGroup'
http GET '{{baseUrl}}/?DBClusterParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBClusterParameterGroup'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBClusterParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBClusterParameterGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBClusterParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBClusterParameterGroup")! 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_ModifyDBClusterSnapshotAttribute
{{baseUrl}}/#Action=ModifyDBClusterSnapshotAttribute
QUERY PARAMS
DBClusterSnapshotIdentifier
AttributeName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?DBClusterSnapshotIdentifier=&AttributeName=&Action=&Version=#Action=ModifyDBClusterSnapshotAttribute");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ModifyDBClusterSnapshotAttribute" {:query-params {:DBClusterSnapshotIdentifier ""
                                                                                                   :AttributeName ""
                                                                                                   :Action ""
                                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?DBClusterSnapshotIdentifier=&AttributeName=&Action=&Version=#Action=ModifyDBClusterSnapshotAttribute"

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}}/?DBClusterSnapshotIdentifier=&AttributeName=&Action=&Version=#Action=ModifyDBClusterSnapshotAttribute"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBClusterSnapshotIdentifier=&AttributeName=&Action=&Version=#Action=ModifyDBClusterSnapshotAttribute");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?DBClusterSnapshotIdentifier=&AttributeName=&Action=&Version=#Action=ModifyDBClusterSnapshotAttribute"

	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/?DBClusterSnapshotIdentifier=&AttributeName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?DBClusterSnapshotIdentifier=&AttributeName=&Action=&Version=#Action=ModifyDBClusterSnapshotAttribute")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBClusterSnapshotIdentifier=&AttributeName=&Action=&Version=#Action=ModifyDBClusterSnapshotAttribute"))
    .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}}/?DBClusterSnapshotIdentifier=&AttributeName=&Action=&Version=#Action=ModifyDBClusterSnapshotAttribute")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBClusterSnapshotIdentifier=&AttributeName=&Action=&Version=#Action=ModifyDBClusterSnapshotAttribute")
  .asString();
const 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}}/?DBClusterSnapshotIdentifier=&AttributeName=&Action=&Version=#Action=ModifyDBClusterSnapshotAttribute');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ModifyDBClusterSnapshotAttribute',
  params: {DBClusterSnapshotIdentifier: '', AttributeName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBClusterSnapshotIdentifier=&AttributeName=&Action=&Version=#Action=ModifyDBClusterSnapshotAttribute';
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}}/?DBClusterSnapshotIdentifier=&AttributeName=&Action=&Version=#Action=ModifyDBClusterSnapshotAttribute',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?DBClusterSnapshotIdentifier=&AttributeName=&Action=&Version=#Action=ModifyDBClusterSnapshotAttribute")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?DBClusterSnapshotIdentifier=&AttributeName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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=ModifyDBClusterSnapshotAttribute',
  qs: {DBClusterSnapshotIdentifier: '', AttributeName: '', 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=ModifyDBClusterSnapshotAttribute');

req.query({
  DBClusterSnapshotIdentifier: '',
  AttributeName: '',
  Action: '',
  Version: ''
});

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=ModifyDBClusterSnapshotAttribute',
  params: {DBClusterSnapshotIdentifier: '', AttributeName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?DBClusterSnapshotIdentifier=&AttributeName=&Action=&Version=#Action=ModifyDBClusterSnapshotAttribute';
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}}/?DBClusterSnapshotIdentifier=&AttributeName=&Action=&Version=#Action=ModifyDBClusterSnapshotAttribute"]
                                                       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}}/?DBClusterSnapshotIdentifier=&AttributeName=&Action=&Version=#Action=ModifyDBClusterSnapshotAttribute" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBClusterSnapshotIdentifier=&AttributeName=&Action=&Version=#Action=ModifyDBClusterSnapshotAttribute",
  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}}/?DBClusterSnapshotIdentifier=&AttributeName=&Action=&Version=#Action=ModifyDBClusterSnapshotAttribute');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ModifyDBClusterSnapshotAttribute');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'DBClusterSnapshotIdentifier' => '',
  'AttributeName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ModifyDBClusterSnapshotAttribute');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'DBClusterSnapshotIdentifier' => '',
  'AttributeName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?DBClusterSnapshotIdentifier=&AttributeName=&Action=&Version=#Action=ModifyDBClusterSnapshotAttribute' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?DBClusterSnapshotIdentifier=&AttributeName=&Action=&Version=#Action=ModifyDBClusterSnapshotAttribute' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?DBClusterSnapshotIdentifier=&AttributeName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ModifyDBClusterSnapshotAttribute"

querystring = {"DBClusterSnapshotIdentifier":"","AttributeName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ModifyDBClusterSnapshotAttribute"

queryString <- list(
  DBClusterSnapshotIdentifier = "",
  AttributeName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?DBClusterSnapshotIdentifier=&AttributeName=&Action=&Version=#Action=ModifyDBClusterSnapshotAttribute")

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['DBClusterSnapshotIdentifier'] = ''
  req.params['AttributeName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ModifyDBClusterSnapshotAttribute";

    let querystring = [
        ("DBClusterSnapshotIdentifier", ""),
        ("AttributeName", ""),
        ("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}}/?DBClusterSnapshotIdentifier=&AttributeName=&Action=&Version=#Action=ModifyDBClusterSnapshotAttribute'
http GET '{{baseUrl}}/?DBClusterSnapshotIdentifier=&AttributeName=&Action=&Version=#Action=ModifyDBClusterSnapshotAttribute'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBClusterSnapshotIdentifier=&AttributeName=&Action=&Version=#Action=ModifyDBClusterSnapshotAttribute'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBClusterSnapshotIdentifier=&AttributeName=&Action=&Version=#Action=ModifyDBClusterSnapshotAttribute")! 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_ModifyDBInstance
{{baseUrl}}/#Action=ModifyDBInstance
QUERY PARAMS
DBInstanceIdentifier
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=ModifyDBInstance");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ModifyDBInstance" {:query-params {:DBInstanceIdentifier ""
                                                                                   :Action ""
                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=ModifyDBInstance"

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}}/?DBInstanceIdentifier=&Action=&Version=#Action=ModifyDBInstance"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=ModifyDBInstance");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=ModifyDBInstance"

	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/?DBInstanceIdentifier=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=ModifyDBInstance")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=ModifyDBInstance"))
    .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}}/?DBInstanceIdentifier=&Action=&Version=#Action=ModifyDBInstance")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=ModifyDBInstance")
  .asString();
const 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}}/?DBInstanceIdentifier=&Action=&Version=#Action=ModifyDBInstance');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ModifyDBInstance',
  params: {DBInstanceIdentifier: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=ModifyDBInstance';
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}}/?DBInstanceIdentifier=&Action=&Version=#Action=ModifyDBInstance',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=ModifyDBInstance")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?DBInstanceIdentifier=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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=ModifyDBInstance',
  qs: {DBInstanceIdentifier: '', 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=ModifyDBInstance');

req.query({
  DBInstanceIdentifier: '',
  Action: '',
  Version: ''
});

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=ModifyDBInstance',
  params: {DBInstanceIdentifier: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=ModifyDBInstance';
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}}/?DBInstanceIdentifier=&Action=&Version=#Action=ModifyDBInstance"]
                                                       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}}/?DBInstanceIdentifier=&Action=&Version=#Action=ModifyDBInstance" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=ModifyDBInstance",
  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}}/?DBInstanceIdentifier=&Action=&Version=#Action=ModifyDBInstance');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ModifyDBInstance');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'DBInstanceIdentifier' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ModifyDBInstance');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'DBInstanceIdentifier' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=ModifyDBInstance' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=ModifyDBInstance' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?DBInstanceIdentifier=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ModifyDBInstance"

querystring = {"DBInstanceIdentifier":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ModifyDBInstance"

queryString <- list(
  DBInstanceIdentifier = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=ModifyDBInstance")

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['DBInstanceIdentifier'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ModifyDBInstance";

    let querystring = [
        ("DBInstanceIdentifier", ""),
        ("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}}/?DBInstanceIdentifier=&Action=&Version=#Action=ModifyDBInstance'
http GET '{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=ModifyDBInstance'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=ModifyDBInstance'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=ModifyDBInstance")! 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_ModifyDBParameterGroup
{{baseUrl}}/#Action=ModifyDBParameterGroup
QUERY PARAMS
DBParameterGroupName
Parameters
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?DBParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBParameterGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ModifyDBParameterGroup" {:query-params {:DBParameterGroupName ""
                                                                                         :Parameters ""
                                                                                         :Action ""
                                                                                         :Version ""}})
require "http/client"

url = "{{baseUrl}}/?DBParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBParameterGroup"

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}}/?DBParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBParameterGroup"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBParameterGroup");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?DBParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBParameterGroup"

	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/?DBParameterGroupName=&Parameters=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?DBParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBParameterGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBParameterGroup"))
    .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}}/?DBParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBParameterGroup")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBParameterGroup")
  .asString();
const 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}}/?DBParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBParameterGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ModifyDBParameterGroup',
  params: {DBParameterGroupName: '', Parameters: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBParameterGroup';
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}}/?DBParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBParameterGroup',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?DBParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBParameterGroup")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?DBParameterGroupName=&Parameters=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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=ModifyDBParameterGroup',
  qs: {DBParameterGroupName: '', Parameters: '', 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=ModifyDBParameterGroup');

req.query({
  DBParameterGroupName: '',
  Parameters: '',
  Action: '',
  Version: ''
});

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=ModifyDBParameterGroup',
  params: {DBParameterGroupName: '', Parameters: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?DBParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBParameterGroup';
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}}/?DBParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBParameterGroup"]
                                                       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}}/?DBParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBParameterGroup" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBParameterGroup",
  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}}/?DBParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBParameterGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ModifyDBParameterGroup');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'DBParameterGroupName' => '',
  'Parameters' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ModifyDBParameterGroup');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'DBParameterGroupName' => '',
  'Parameters' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?DBParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBParameterGroup' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?DBParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBParameterGroup' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?DBParameterGroupName=&Parameters=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ModifyDBParameterGroup"

querystring = {"DBParameterGroupName":"","Parameters":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ModifyDBParameterGroup"

queryString <- list(
  DBParameterGroupName = "",
  Parameters = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?DBParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBParameterGroup")

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['DBParameterGroupName'] = ''
  req.params['Parameters'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ModifyDBParameterGroup";

    let querystring = [
        ("DBParameterGroupName", ""),
        ("Parameters", ""),
        ("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}}/?DBParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBParameterGroup'
http GET '{{baseUrl}}/?DBParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBParameterGroup'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBParameterGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBParameterGroupName=&Parameters=&Action=&Version=#Action=ModifyDBParameterGroup")! 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_ModifyDBSubnetGroup
{{baseUrl}}/#Action=ModifyDBSubnetGroup
QUERY PARAMS
DBSubnetGroupName
SubnetIds
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?DBSubnetGroupName=&SubnetIds=&Action=&Version=#Action=ModifyDBSubnetGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ModifyDBSubnetGroup" {:query-params {:DBSubnetGroupName ""
                                                                                      :SubnetIds ""
                                                                                      :Action ""
                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?DBSubnetGroupName=&SubnetIds=&Action=&Version=#Action=ModifyDBSubnetGroup"

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}}/?DBSubnetGroupName=&SubnetIds=&Action=&Version=#Action=ModifyDBSubnetGroup"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBSubnetGroupName=&SubnetIds=&Action=&Version=#Action=ModifyDBSubnetGroup");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?DBSubnetGroupName=&SubnetIds=&Action=&Version=#Action=ModifyDBSubnetGroup"

	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/?DBSubnetGroupName=&SubnetIds=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?DBSubnetGroupName=&SubnetIds=&Action=&Version=#Action=ModifyDBSubnetGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBSubnetGroupName=&SubnetIds=&Action=&Version=#Action=ModifyDBSubnetGroup"))
    .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}}/?DBSubnetGroupName=&SubnetIds=&Action=&Version=#Action=ModifyDBSubnetGroup")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBSubnetGroupName=&SubnetIds=&Action=&Version=#Action=ModifyDBSubnetGroup")
  .asString();
const 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}}/?DBSubnetGroupName=&SubnetIds=&Action=&Version=#Action=ModifyDBSubnetGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ModifyDBSubnetGroup',
  params: {DBSubnetGroupName: '', SubnetIds: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBSubnetGroupName=&SubnetIds=&Action=&Version=#Action=ModifyDBSubnetGroup';
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}}/?DBSubnetGroupName=&SubnetIds=&Action=&Version=#Action=ModifyDBSubnetGroup',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?DBSubnetGroupName=&SubnetIds=&Action=&Version=#Action=ModifyDBSubnetGroup")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?DBSubnetGroupName=&SubnetIds=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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=ModifyDBSubnetGroup',
  qs: {DBSubnetGroupName: '', SubnetIds: '', 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=ModifyDBSubnetGroup');

req.query({
  DBSubnetGroupName: '',
  SubnetIds: '',
  Action: '',
  Version: ''
});

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=ModifyDBSubnetGroup',
  params: {DBSubnetGroupName: '', SubnetIds: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?DBSubnetGroupName=&SubnetIds=&Action=&Version=#Action=ModifyDBSubnetGroup';
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}}/?DBSubnetGroupName=&SubnetIds=&Action=&Version=#Action=ModifyDBSubnetGroup"]
                                                       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}}/?DBSubnetGroupName=&SubnetIds=&Action=&Version=#Action=ModifyDBSubnetGroup" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBSubnetGroupName=&SubnetIds=&Action=&Version=#Action=ModifyDBSubnetGroup",
  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}}/?DBSubnetGroupName=&SubnetIds=&Action=&Version=#Action=ModifyDBSubnetGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ModifyDBSubnetGroup');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'DBSubnetGroupName' => '',
  'SubnetIds' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ModifyDBSubnetGroup');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'DBSubnetGroupName' => '',
  'SubnetIds' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?DBSubnetGroupName=&SubnetIds=&Action=&Version=#Action=ModifyDBSubnetGroup' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?DBSubnetGroupName=&SubnetIds=&Action=&Version=#Action=ModifyDBSubnetGroup' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?DBSubnetGroupName=&SubnetIds=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ModifyDBSubnetGroup"

querystring = {"DBSubnetGroupName":"","SubnetIds":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ModifyDBSubnetGroup"

queryString <- list(
  DBSubnetGroupName = "",
  SubnetIds = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?DBSubnetGroupName=&SubnetIds=&Action=&Version=#Action=ModifyDBSubnetGroup")

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['DBSubnetGroupName'] = ''
  req.params['SubnetIds'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ModifyDBSubnetGroup";

    let querystring = [
        ("DBSubnetGroupName", ""),
        ("SubnetIds", ""),
        ("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}}/?DBSubnetGroupName=&SubnetIds=&Action=&Version=#Action=ModifyDBSubnetGroup'
http GET '{{baseUrl}}/?DBSubnetGroupName=&SubnetIds=&Action=&Version=#Action=ModifyDBSubnetGroup'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBSubnetGroupName=&SubnetIds=&Action=&Version=#Action=ModifyDBSubnetGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBSubnetGroupName=&SubnetIds=&Action=&Version=#Action=ModifyDBSubnetGroup")! 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_ModifyEventSubscription
{{baseUrl}}/#Action=ModifyEventSubscription
QUERY PARAMS
SubscriptionName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?SubscriptionName=&Action=&Version=#Action=ModifyEventSubscription");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ModifyEventSubscription" {:query-params {:SubscriptionName ""
                                                                                          :Action ""
                                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?SubscriptionName=&Action=&Version=#Action=ModifyEventSubscription"

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}}/?SubscriptionName=&Action=&Version=#Action=ModifyEventSubscription"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?SubscriptionName=&Action=&Version=#Action=ModifyEventSubscription");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?SubscriptionName=&Action=&Version=#Action=ModifyEventSubscription"

	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/?SubscriptionName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?SubscriptionName=&Action=&Version=#Action=ModifyEventSubscription")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?SubscriptionName=&Action=&Version=#Action=ModifyEventSubscription"))
    .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}}/?SubscriptionName=&Action=&Version=#Action=ModifyEventSubscription")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?SubscriptionName=&Action=&Version=#Action=ModifyEventSubscription")
  .asString();
const 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}}/?SubscriptionName=&Action=&Version=#Action=ModifyEventSubscription');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ModifyEventSubscription',
  params: {SubscriptionName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?SubscriptionName=&Action=&Version=#Action=ModifyEventSubscription';
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}}/?SubscriptionName=&Action=&Version=#Action=ModifyEventSubscription',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?SubscriptionName=&Action=&Version=#Action=ModifyEventSubscription")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?SubscriptionName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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=ModifyEventSubscription',
  qs: {SubscriptionName: '', 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=ModifyEventSubscription');

req.query({
  SubscriptionName: '',
  Action: '',
  Version: ''
});

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=ModifyEventSubscription',
  params: {SubscriptionName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?SubscriptionName=&Action=&Version=#Action=ModifyEventSubscription';
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}}/?SubscriptionName=&Action=&Version=#Action=ModifyEventSubscription"]
                                                       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}}/?SubscriptionName=&Action=&Version=#Action=ModifyEventSubscription" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?SubscriptionName=&Action=&Version=#Action=ModifyEventSubscription",
  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}}/?SubscriptionName=&Action=&Version=#Action=ModifyEventSubscription');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ModifyEventSubscription');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'SubscriptionName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ModifyEventSubscription');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'SubscriptionName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?SubscriptionName=&Action=&Version=#Action=ModifyEventSubscription' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?SubscriptionName=&Action=&Version=#Action=ModifyEventSubscription' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?SubscriptionName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ModifyEventSubscription"

querystring = {"SubscriptionName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ModifyEventSubscription"

queryString <- list(
  SubscriptionName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?SubscriptionName=&Action=&Version=#Action=ModifyEventSubscription")

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['SubscriptionName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ModifyEventSubscription";

    let querystring = [
        ("SubscriptionName", ""),
        ("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}}/?SubscriptionName=&Action=&Version=#Action=ModifyEventSubscription'
http GET '{{baseUrl}}/?SubscriptionName=&Action=&Version=#Action=ModifyEventSubscription'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?SubscriptionName=&Action=&Version=#Action=ModifyEventSubscription'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?SubscriptionName=&Action=&Version=#Action=ModifyEventSubscription")! 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_ModifyGlobalCluster
{{baseUrl}}/#Action=ModifyGlobalCluster
QUERY PARAMS
GlobalClusterIdentifier
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=ModifyGlobalCluster");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ModifyGlobalCluster" {:query-params {:GlobalClusterIdentifier ""
                                                                                      :Action ""
                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=ModifyGlobalCluster"

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}}/?GlobalClusterIdentifier=&Action=&Version=#Action=ModifyGlobalCluster"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=ModifyGlobalCluster");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=ModifyGlobalCluster"

	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/?GlobalClusterIdentifier=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=ModifyGlobalCluster")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=ModifyGlobalCluster"))
    .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}}/?GlobalClusterIdentifier=&Action=&Version=#Action=ModifyGlobalCluster")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=ModifyGlobalCluster")
  .asString();
const 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}}/?GlobalClusterIdentifier=&Action=&Version=#Action=ModifyGlobalCluster');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ModifyGlobalCluster',
  params: {GlobalClusterIdentifier: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=ModifyGlobalCluster';
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}}/?GlobalClusterIdentifier=&Action=&Version=#Action=ModifyGlobalCluster',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=ModifyGlobalCluster")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?GlobalClusterIdentifier=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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=ModifyGlobalCluster',
  qs: {GlobalClusterIdentifier: '', 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=ModifyGlobalCluster');

req.query({
  GlobalClusterIdentifier: '',
  Action: '',
  Version: ''
});

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=ModifyGlobalCluster',
  params: {GlobalClusterIdentifier: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=ModifyGlobalCluster';
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}}/?GlobalClusterIdentifier=&Action=&Version=#Action=ModifyGlobalCluster"]
                                                       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}}/?GlobalClusterIdentifier=&Action=&Version=#Action=ModifyGlobalCluster" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=ModifyGlobalCluster",
  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}}/?GlobalClusterIdentifier=&Action=&Version=#Action=ModifyGlobalCluster');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ModifyGlobalCluster');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'GlobalClusterIdentifier' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ModifyGlobalCluster');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'GlobalClusterIdentifier' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=ModifyGlobalCluster' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=ModifyGlobalCluster' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?GlobalClusterIdentifier=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ModifyGlobalCluster"

querystring = {"GlobalClusterIdentifier":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ModifyGlobalCluster"

queryString <- list(
  GlobalClusterIdentifier = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=ModifyGlobalCluster")

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['GlobalClusterIdentifier'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ModifyGlobalCluster";

    let querystring = [
        ("GlobalClusterIdentifier", ""),
        ("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}}/?GlobalClusterIdentifier=&Action=&Version=#Action=ModifyGlobalCluster'
http GET '{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=ModifyGlobalCluster'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=ModifyGlobalCluster'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?GlobalClusterIdentifier=&Action=&Version=#Action=ModifyGlobalCluster")! 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_PromoteReadReplicaDBCluster
{{baseUrl}}/#Action=PromoteReadReplicaDBCluster
QUERY PARAMS
DBClusterIdentifier
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=PromoteReadReplicaDBCluster");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=PromoteReadReplicaDBCluster" {:query-params {:DBClusterIdentifier ""
                                                                                              :Action ""
                                                                                              :Version ""}})
require "http/client"

url = "{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=PromoteReadReplicaDBCluster"

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}}/?DBClusterIdentifier=&Action=&Version=#Action=PromoteReadReplicaDBCluster"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=PromoteReadReplicaDBCluster");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=PromoteReadReplicaDBCluster"

	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/?DBClusterIdentifier=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=PromoteReadReplicaDBCluster")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=PromoteReadReplicaDBCluster"))
    .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}}/?DBClusterIdentifier=&Action=&Version=#Action=PromoteReadReplicaDBCluster")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=PromoteReadReplicaDBCluster")
  .asString();
const 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}}/?DBClusterIdentifier=&Action=&Version=#Action=PromoteReadReplicaDBCluster');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=PromoteReadReplicaDBCluster',
  params: {DBClusterIdentifier: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=PromoteReadReplicaDBCluster';
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}}/?DBClusterIdentifier=&Action=&Version=#Action=PromoteReadReplicaDBCluster',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=PromoteReadReplicaDBCluster")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?DBClusterIdentifier=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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=PromoteReadReplicaDBCluster',
  qs: {DBClusterIdentifier: '', 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=PromoteReadReplicaDBCluster');

req.query({
  DBClusterIdentifier: '',
  Action: '',
  Version: ''
});

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=PromoteReadReplicaDBCluster',
  params: {DBClusterIdentifier: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=PromoteReadReplicaDBCluster';
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}}/?DBClusterIdentifier=&Action=&Version=#Action=PromoteReadReplicaDBCluster"]
                                                       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}}/?DBClusterIdentifier=&Action=&Version=#Action=PromoteReadReplicaDBCluster" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=PromoteReadReplicaDBCluster",
  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}}/?DBClusterIdentifier=&Action=&Version=#Action=PromoteReadReplicaDBCluster');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=PromoteReadReplicaDBCluster');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'DBClusterIdentifier' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=PromoteReadReplicaDBCluster');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'DBClusterIdentifier' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=PromoteReadReplicaDBCluster' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=PromoteReadReplicaDBCluster' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?DBClusterIdentifier=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=PromoteReadReplicaDBCluster"

querystring = {"DBClusterIdentifier":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=PromoteReadReplicaDBCluster"

queryString <- list(
  DBClusterIdentifier = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=PromoteReadReplicaDBCluster")

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['DBClusterIdentifier'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=PromoteReadReplicaDBCluster";

    let querystring = [
        ("DBClusterIdentifier", ""),
        ("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}}/?DBClusterIdentifier=&Action=&Version=#Action=PromoteReadReplicaDBCluster'
http GET '{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=PromoteReadReplicaDBCluster'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=PromoteReadReplicaDBCluster'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=PromoteReadReplicaDBCluster")! 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_RebootDBInstance
{{baseUrl}}/#Action=RebootDBInstance
QUERY PARAMS
DBInstanceIdentifier
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=RebootDBInstance");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=RebootDBInstance" {:query-params {:DBInstanceIdentifier ""
                                                                                   :Action ""
                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=RebootDBInstance"

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}}/?DBInstanceIdentifier=&Action=&Version=#Action=RebootDBInstance"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=RebootDBInstance");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=RebootDBInstance"

	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/?DBInstanceIdentifier=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=RebootDBInstance")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=RebootDBInstance"))
    .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}}/?DBInstanceIdentifier=&Action=&Version=#Action=RebootDBInstance")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=RebootDBInstance")
  .asString();
const 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}}/?DBInstanceIdentifier=&Action=&Version=#Action=RebootDBInstance');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=RebootDBInstance',
  params: {DBInstanceIdentifier: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=RebootDBInstance';
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}}/?DBInstanceIdentifier=&Action=&Version=#Action=RebootDBInstance',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=RebootDBInstance")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?DBInstanceIdentifier=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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=RebootDBInstance',
  qs: {DBInstanceIdentifier: '', 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=RebootDBInstance');

req.query({
  DBInstanceIdentifier: '',
  Action: '',
  Version: ''
});

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=RebootDBInstance',
  params: {DBInstanceIdentifier: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=RebootDBInstance';
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}}/?DBInstanceIdentifier=&Action=&Version=#Action=RebootDBInstance"]
                                                       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}}/?DBInstanceIdentifier=&Action=&Version=#Action=RebootDBInstance" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=RebootDBInstance",
  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}}/?DBInstanceIdentifier=&Action=&Version=#Action=RebootDBInstance');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=RebootDBInstance');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'DBInstanceIdentifier' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=RebootDBInstance');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'DBInstanceIdentifier' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=RebootDBInstance' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=RebootDBInstance' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?DBInstanceIdentifier=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=RebootDBInstance"

querystring = {"DBInstanceIdentifier":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=RebootDBInstance"

queryString <- list(
  DBInstanceIdentifier = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=RebootDBInstance")

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['DBInstanceIdentifier'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=RebootDBInstance";

    let querystring = [
        ("DBInstanceIdentifier", ""),
        ("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}}/?DBInstanceIdentifier=&Action=&Version=#Action=RebootDBInstance'
http GET '{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=RebootDBInstance'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=RebootDBInstance'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBInstanceIdentifier=&Action=&Version=#Action=RebootDBInstance")! 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_RemoveFromGlobalCluster
{{baseUrl}}/#Action=RemoveFromGlobalCluster
QUERY PARAMS
GlobalClusterIdentifier
DbClusterIdentifier
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?GlobalClusterIdentifier=&DbClusterIdentifier=&Action=&Version=#Action=RemoveFromGlobalCluster");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=RemoveFromGlobalCluster" {:query-params {:GlobalClusterIdentifier ""
                                                                                          :DbClusterIdentifier ""
                                                                                          :Action ""
                                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?GlobalClusterIdentifier=&DbClusterIdentifier=&Action=&Version=#Action=RemoveFromGlobalCluster"

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}}/?GlobalClusterIdentifier=&DbClusterIdentifier=&Action=&Version=#Action=RemoveFromGlobalCluster"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?GlobalClusterIdentifier=&DbClusterIdentifier=&Action=&Version=#Action=RemoveFromGlobalCluster");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?GlobalClusterIdentifier=&DbClusterIdentifier=&Action=&Version=#Action=RemoveFromGlobalCluster"

	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/?GlobalClusterIdentifier=&DbClusterIdentifier=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?GlobalClusterIdentifier=&DbClusterIdentifier=&Action=&Version=#Action=RemoveFromGlobalCluster")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?GlobalClusterIdentifier=&DbClusterIdentifier=&Action=&Version=#Action=RemoveFromGlobalCluster"))
    .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}}/?GlobalClusterIdentifier=&DbClusterIdentifier=&Action=&Version=#Action=RemoveFromGlobalCluster")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?GlobalClusterIdentifier=&DbClusterIdentifier=&Action=&Version=#Action=RemoveFromGlobalCluster")
  .asString();
const 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}}/?GlobalClusterIdentifier=&DbClusterIdentifier=&Action=&Version=#Action=RemoveFromGlobalCluster');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=RemoveFromGlobalCluster',
  params: {GlobalClusterIdentifier: '', DbClusterIdentifier: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?GlobalClusterIdentifier=&DbClusterIdentifier=&Action=&Version=#Action=RemoveFromGlobalCluster';
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}}/?GlobalClusterIdentifier=&DbClusterIdentifier=&Action=&Version=#Action=RemoveFromGlobalCluster',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?GlobalClusterIdentifier=&DbClusterIdentifier=&Action=&Version=#Action=RemoveFromGlobalCluster")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?GlobalClusterIdentifier=&DbClusterIdentifier=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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=RemoveFromGlobalCluster',
  qs: {GlobalClusterIdentifier: '', DbClusterIdentifier: '', 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=RemoveFromGlobalCluster');

req.query({
  GlobalClusterIdentifier: '',
  DbClusterIdentifier: '',
  Action: '',
  Version: ''
});

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=RemoveFromGlobalCluster',
  params: {GlobalClusterIdentifier: '', DbClusterIdentifier: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?GlobalClusterIdentifier=&DbClusterIdentifier=&Action=&Version=#Action=RemoveFromGlobalCluster';
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}}/?GlobalClusterIdentifier=&DbClusterIdentifier=&Action=&Version=#Action=RemoveFromGlobalCluster"]
                                                       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}}/?GlobalClusterIdentifier=&DbClusterIdentifier=&Action=&Version=#Action=RemoveFromGlobalCluster" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?GlobalClusterIdentifier=&DbClusterIdentifier=&Action=&Version=#Action=RemoveFromGlobalCluster",
  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}}/?GlobalClusterIdentifier=&DbClusterIdentifier=&Action=&Version=#Action=RemoveFromGlobalCluster');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=RemoveFromGlobalCluster');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'GlobalClusterIdentifier' => '',
  'DbClusterIdentifier' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=RemoveFromGlobalCluster');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'GlobalClusterIdentifier' => '',
  'DbClusterIdentifier' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?GlobalClusterIdentifier=&DbClusterIdentifier=&Action=&Version=#Action=RemoveFromGlobalCluster' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?GlobalClusterIdentifier=&DbClusterIdentifier=&Action=&Version=#Action=RemoveFromGlobalCluster' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?GlobalClusterIdentifier=&DbClusterIdentifier=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=RemoveFromGlobalCluster"

querystring = {"GlobalClusterIdentifier":"","DbClusterIdentifier":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=RemoveFromGlobalCluster"

queryString <- list(
  GlobalClusterIdentifier = "",
  DbClusterIdentifier = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?GlobalClusterIdentifier=&DbClusterIdentifier=&Action=&Version=#Action=RemoveFromGlobalCluster")

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['GlobalClusterIdentifier'] = ''
  req.params['DbClusterIdentifier'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=RemoveFromGlobalCluster";

    let querystring = [
        ("GlobalClusterIdentifier", ""),
        ("DbClusterIdentifier", ""),
        ("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}}/?GlobalClusterIdentifier=&DbClusterIdentifier=&Action=&Version=#Action=RemoveFromGlobalCluster'
http GET '{{baseUrl}}/?GlobalClusterIdentifier=&DbClusterIdentifier=&Action=&Version=#Action=RemoveFromGlobalCluster'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?GlobalClusterIdentifier=&DbClusterIdentifier=&Action=&Version=#Action=RemoveFromGlobalCluster'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?GlobalClusterIdentifier=&DbClusterIdentifier=&Action=&Version=#Action=RemoveFromGlobalCluster")! 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_RemoveRoleFromDBCluster
{{baseUrl}}/#Action=RemoveRoleFromDBCluster
QUERY PARAMS
DBClusterIdentifier
RoleArn
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=RemoveRoleFromDBCluster");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=RemoveRoleFromDBCluster" {:query-params {:DBClusterIdentifier ""
                                                                                          :RoleArn ""
                                                                                          :Action ""
                                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=RemoveRoleFromDBCluster"

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}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=RemoveRoleFromDBCluster"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=RemoveRoleFromDBCluster");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=RemoveRoleFromDBCluster"

	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/?DBClusterIdentifier=&RoleArn=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=RemoveRoleFromDBCluster")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=RemoveRoleFromDBCluster"))
    .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}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=RemoveRoleFromDBCluster")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=RemoveRoleFromDBCluster")
  .asString();
const 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}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=RemoveRoleFromDBCluster');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=RemoveRoleFromDBCluster',
  params: {DBClusterIdentifier: '', RoleArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=RemoveRoleFromDBCluster';
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}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=RemoveRoleFromDBCluster',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=RemoveRoleFromDBCluster")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?DBClusterIdentifier=&RoleArn=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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=RemoveRoleFromDBCluster',
  qs: {DBClusterIdentifier: '', RoleArn: '', 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=RemoveRoleFromDBCluster');

req.query({
  DBClusterIdentifier: '',
  RoleArn: '',
  Action: '',
  Version: ''
});

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=RemoveRoleFromDBCluster',
  params: {DBClusterIdentifier: '', RoleArn: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=RemoveRoleFromDBCluster';
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}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=RemoveRoleFromDBCluster"]
                                                       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}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=RemoveRoleFromDBCluster" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=RemoveRoleFromDBCluster",
  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}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=RemoveRoleFromDBCluster');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=RemoveRoleFromDBCluster');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'DBClusterIdentifier' => '',
  'RoleArn' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=RemoveRoleFromDBCluster');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'DBClusterIdentifier' => '',
  'RoleArn' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=RemoveRoleFromDBCluster' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=RemoveRoleFromDBCluster' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?DBClusterIdentifier=&RoleArn=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=RemoveRoleFromDBCluster"

querystring = {"DBClusterIdentifier":"","RoleArn":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=RemoveRoleFromDBCluster"

queryString <- list(
  DBClusterIdentifier = "",
  RoleArn = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=RemoveRoleFromDBCluster")

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['DBClusterIdentifier'] = ''
  req.params['RoleArn'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=RemoveRoleFromDBCluster";

    let querystring = [
        ("DBClusterIdentifier", ""),
        ("RoleArn", ""),
        ("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}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=RemoveRoleFromDBCluster'
http GET '{{baseUrl}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=RemoveRoleFromDBCluster'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=RemoveRoleFromDBCluster'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBClusterIdentifier=&RoleArn=&Action=&Version=#Action=RemoveRoleFromDBCluster")! 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_RemoveSourceIdentifierFromSubscription
{{baseUrl}}/#Action=RemoveSourceIdentifierFromSubscription
QUERY PARAMS
SubscriptionName
SourceIdentifier
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=RemoveSourceIdentifierFromSubscription");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=RemoveSourceIdentifierFromSubscription" {:query-params {:SubscriptionName ""
                                                                                                         :SourceIdentifier ""
                                                                                                         :Action ""
                                                                                                         :Version ""}})
require "http/client"

url = "{{baseUrl}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=RemoveSourceIdentifierFromSubscription"

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}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=RemoveSourceIdentifierFromSubscription"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=RemoveSourceIdentifierFromSubscription");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=RemoveSourceIdentifierFromSubscription"

	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/?SubscriptionName=&SourceIdentifier=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=RemoveSourceIdentifierFromSubscription")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=RemoveSourceIdentifierFromSubscription"))
    .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}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=RemoveSourceIdentifierFromSubscription")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=RemoveSourceIdentifierFromSubscription")
  .asString();
const 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}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=RemoveSourceIdentifierFromSubscription');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=RemoveSourceIdentifierFromSubscription',
  params: {SubscriptionName: '', SourceIdentifier: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=RemoveSourceIdentifierFromSubscription';
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}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=RemoveSourceIdentifierFromSubscription',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=RemoveSourceIdentifierFromSubscription")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?SubscriptionName=&SourceIdentifier=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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=RemoveSourceIdentifierFromSubscription',
  qs: {SubscriptionName: '', SourceIdentifier: '', 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=RemoveSourceIdentifierFromSubscription');

req.query({
  SubscriptionName: '',
  SourceIdentifier: '',
  Action: '',
  Version: ''
});

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=RemoveSourceIdentifierFromSubscription',
  params: {SubscriptionName: '', SourceIdentifier: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=RemoveSourceIdentifierFromSubscription';
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}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=RemoveSourceIdentifierFromSubscription"]
                                                       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}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=RemoveSourceIdentifierFromSubscription" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=RemoveSourceIdentifierFromSubscription",
  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}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=RemoveSourceIdentifierFromSubscription');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=RemoveSourceIdentifierFromSubscription');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'SubscriptionName' => '',
  'SourceIdentifier' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=RemoveSourceIdentifierFromSubscription');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'SubscriptionName' => '',
  'SourceIdentifier' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=RemoveSourceIdentifierFromSubscription' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=RemoveSourceIdentifierFromSubscription' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?SubscriptionName=&SourceIdentifier=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=RemoveSourceIdentifierFromSubscription"

querystring = {"SubscriptionName":"","SourceIdentifier":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=RemoveSourceIdentifierFromSubscription"

queryString <- list(
  SubscriptionName = "",
  SourceIdentifier = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=RemoveSourceIdentifierFromSubscription")

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['SubscriptionName'] = ''
  req.params['SourceIdentifier'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=RemoveSourceIdentifierFromSubscription";

    let querystring = [
        ("SubscriptionName", ""),
        ("SourceIdentifier", ""),
        ("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}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=RemoveSourceIdentifierFromSubscription'
http GET '{{baseUrl}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=RemoveSourceIdentifierFromSubscription'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=RemoveSourceIdentifierFromSubscription'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?SubscriptionName=&SourceIdentifier=&Action=&Version=#Action=RemoveSourceIdentifierFromSubscription")! 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_RemoveTagsFromResource
{{baseUrl}}/#Action=RemoveTagsFromResource
QUERY PARAMS
ResourceName
TagKeys
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?ResourceName=&TagKeys=&Action=&Version=#Action=RemoveTagsFromResource");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=RemoveTagsFromResource" {:query-params {:ResourceName ""
                                                                                         :TagKeys ""
                                                                                         :Action ""
                                                                                         :Version ""}})
require "http/client"

url = "{{baseUrl}}/?ResourceName=&TagKeys=&Action=&Version=#Action=RemoveTagsFromResource"

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}}/?ResourceName=&TagKeys=&Action=&Version=#Action=RemoveTagsFromResource"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?ResourceName=&TagKeys=&Action=&Version=#Action=RemoveTagsFromResource");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?ResourceName=&TagKeys=&Action=&Version=#Action=RemoveTagsFromResource"

	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/?ResourceName=&TagKeys=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?ResourceName=&TagKeys=&Action=&Version=#Action=RemoveTagsFromResource")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?ResourceName=&TagKeys=&Action=&Version=#Action=RemoveTagsFromResource"))
    .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}}/?ResourceName=&TagKeys=&Action=&Version=#Action=RemoveTagsFromResource")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?ResourceName=&TagKeys=&Action=&Version=#Action=RemoveTagsFromResource")
  .asString();
const 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}}/?ResourceName=&TagKeys=&Action=&Version=#Action=RemoveTagsFromResource');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=RemoveTagsFromResource',
  params: {ResourceName: '', TagKeys: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?ResourceName=&TagKeys=&Action=&Version=#Action=RemoveTagsFromResource';
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}}/?ResourceName=&TagKeys=&Action=&Version=#Action=RemoveTagsFromResource',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?ResourceName=&TagKeys=&Action=&Version=#Action=RemoveTagsFromResource")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?ResourceName=&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=RemoveTagsFromResource',
  qs: {ResourceName: '', 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=RemoveTagsFromResource');

req.query({
  ResourceName: '',
  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=RemoveTagsFromResource',
  params: {ResourceName: '', 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}}/?ResourceName=&TagKeys=&Action=&Version=#Action=RemoveTagsFromResource';
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}}/?ResourceName=&TagKeys=&Action=&Version=#Action=RemoveTagsFromResource"]
                                                       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}}/?ResourceName=&TagKeys=&Action=&Version=#Action=RemoveTagsFromResource" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?ResourceName=&TagKeys=&Action=&Version=#Action=RemoveTagsFromResource",
  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}}/?ResourceName=&TagKeys=&Action=&Version=#Action=RemoveTagsFromResource');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=RemoveTagsFromResource');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'ResourceName' => '',
  'TagKeys' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=RemoveTagsFromResource');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'ResourceName' => '',
  'TagKeys' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?ResourceName=&TagKeys=&Action=&Version=#Action=RemoveTagsFromResource' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?ResourceName=&TagKeys=&Action=&Version=#Action=RemoveTagsFromResource' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?ResourceName=&TagKeys=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=RemoveTagsFromResource"

querystring = {"ResourceName":"","TagKeys":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=RemoveTagsFromResource"

queryString <- list(
  ResourceName = "",
  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}}/?ResourceName=&TagKeys=&Action=&Version=#Action=RemoveTagsFromResource")

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['ResourceName'] = ''
  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=RemoveTagsFromResource";

    let querystring = [
        ("ResourceName", ""),
        ("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}}/?ResourceName=&TagKeys=&Action=&Version=#Action=RemoveTagsFromResource'
http GET '{{baseUrl}}/?ResourceName=&TagKeys=&Action=&Version=#Action=RemoveTagsFromResource'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?ResourceName=&TagKeys=&Action=&Version=#Action=RemoveTagsFromResource'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?ResourceName=&TagKeys=&Action=&Version=#Action=RemoveTagsFromResource")! 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_ResetDBClusterParameterGroup
{{baseUrl}}/#Action=ResetDBClusterParameterGroup
QUERY PARAMS
DBClusterParameterGroupName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=ResetDBClusterParameterGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ResetDBClusterParameterGroup" {:query-params {:DBClusterParameterGroupName ""
                                                                                               :Action ""
                                                                                               :Version ""}})
require "http/client"

url = "{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=ResetDBClusterParameterGroup"

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}}/?DBClusterParameterGroupName=&Action=&Version=#Action=ResetDBClusterParameterGroup"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=ResetDBClusterParameterGroup");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=ResetDBClusterParameterGroup"

	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/?DBClusterParameterGroupName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=ResetDBClusterParameterGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=ResetDBClusterParameterGroup"))
    .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}}/?DBClusterParameterGroupName=&Action=&Version=#Action=ResetDBClusterParameterGroup")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=ResetDBClusterParameterGroup")
  .asString();
const 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}}/?DBClusterParameterGroupName=&Action=&Version=#Action=ResetDBClusterParameterGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ResetDBClusterParameterGroup',
  params: {DBClusterParameterGroupName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=ResetDBClusterParameterGroup';
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}}/?DBClusterParameterGroupName=&Action=&Version=#Action=ResetDBClusterParameterGroup',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=ResetDBClusterParameterGroup")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?DBClusterParameterGroupName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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=ResetDBClusterParameterGroup',
  qs: {DBClusterParameterGroupName: '', 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=ResetDBClusterParameterGroup');

req.query({
  DBClusterParameterGroupName: '',
  Action: '',
  Version: ''
});

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=ResetDBClusterParameterGroup',
  params: {DBClusterParameterGroupName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=ResetDBClusterParameterGroup';
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}}/?DBClusterParameterGroupName=&Action=&Version=#Action=ResetDBClusterParameterGroup"]
                                                       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}}/?DBClusterParameterGroupName=&Action=&Version=#Action=ResetDBClusterParameterGroup" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=ResetDBClusterParameterGroup",
  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}}/?DBClusterParameterGroupName=&Action=&Version=#Action=ResetDBClusterParameterGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ResetDBClusterParameterGroup');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'DBClusterParameterGroupName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ResetDBClusterParameterGroup');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'DBClusterParameterGroupName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=ResetDBClusterParameterGroup' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=ResetDBClusterParameterGroup' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?DBClusterParameterGroupName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ResetDBClusterParameterGroup"

querystring = {"DBClusterParameterGroupName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ResetDBClusterParameterGroup"

queryString <- list(
  DBClusterParameterGroupName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=ResetDBClusterParameterGroup")

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['DBClusterParameterGroupName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ResetDBClusterParameterGroup";

    let querystring = [
        ("DBClusterParameterGroupName", ""),
        ("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}}/?DBClusterParameterGroupName=&Action=&Version=#Action=ResetDBClusterParameterGroup'
http GET '{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=ResetDBClusterParameterGroup'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=ResetDBClusterParameterGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBClusterParameterGroupName=&Action=&Version=#Action=ResetDBClusterParameterGroup")! 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_ResetDBParameterGroup
{{baseUrl}}/#Action=ResetDBParameterGroup
QUERY PARAMS
DBParameterGroupName
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=ResetDBParameterGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=ResetDBParameterGroup" {:query-params {:DBParameterGroupName ""
                                                                                        :Action ""
                                                                                        :Version ""}})
require "http/client"

url = "{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=ResetDBParameterGroup"

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}}/?DBParameterGroupName=&Action=&Version=#Action=ResetDBParameterGroup"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=ResetDBParameterGroup");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=ResetDBParameterGroup"

	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/?DBParameterGroupName=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=ResetDBParameterGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=ResetDBParameterGroup"))
    .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}}/?DBParameterGroupName=&Action=&Version=#Action=ResetDBParameterGroup")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=ResetDBParameterGroup")
  .asString();
const 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}}/?DBParameterGroupName=&Action=&Version=#Action=ResetDBParameterGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=ResetDBParameterGroup',
  params: {DBParameterGroupName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=ResetDBParameterGroup';
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}}/?DBParameterGroupName=&Action=&Version=#Action=ResetDBParameterGroup',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=ResetDBParameterGroup")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?DBParameterGroupName=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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=ResetDBParameterGroup',
  qs: {DBParameterGroupName: '', 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=ResetDBParameterGroup');

req.query({
  DBParameterGroupName: '',
  Action: '',
  Version: ''
});

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=ResetDBParameterGroup',
  params: {DBParameterGroupName: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=ResetDBParameterGroup';
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}}/?DBParameterGroupName=&Action=&Version=#Action=ResetDBParameterGroup"]
                                                       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}}/?DBParameterGroupName=&Action=&Version=#Action=ResetDBParameterGroup" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=ResetDBParameterGroup",
  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}}/?DBParameterGroupName=&Action=&Version=#Action=ResetDBParameterGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ResetDBParameterGroup');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'DBParameterGroupName' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ResetDBParameterGroup');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'DBParameterGroupName' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=ResetDBParameterGroup' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=ResetDBParameterGroup' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?DBParameterGroupName=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=ResetDBParameterGroup"

querystring = {"DBParameterGroupName":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ResetDBParameterGroup"

queryString <- list(
  DBParameterGroupName = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=ResetDBParameterGroup")

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['DBParameterGroupName'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=ResetDBParameterGroup";

    let querystring = [
        ("DBParameterGroupName", ""),
        ("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}}/?DBParameterGroupName=&Action=&Version=#Action=ResetDBParameterGroup'
http GET '{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=ResetDBParameterGroup'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=ResetDBParameterGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBParameterGroupName=&Action=&Version=#Action=ResetDBParameterGroup")! 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_RestoreDBClusterFromSnapshot
{{baseUrl}}/#Action=RestoreDBClusterFromSnapshot
QUERY PARAMS
DBClusterIdentifier
SnapshotIdentifier
Engine
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?DBClusterIdentifier=&SnapshotIdentifier=&Engine=&Action=&Version=#Action=RestoreDBClusterFromSnapshot");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=RestoreDBClusterFromSnapshot" {:query-params {:DBClusterIdentifier ""
                                                                                               :SnapshotIdentifier ""
                                                                                               :Engine ""
                                                                                               :Action ""
                                                                                               :Version ""}})
require "http/client"

url = "{{baseUrl}}/?DBClusterIdentifier=&SnapshotIdentifier=&Engine=&Action=&Version=#Action=RestoreDBClusterFromSnapshot"

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}}/?DBClusterIdentifier=&SnapshotIdentifier=&Engine=&Action=&Version=#Action=RestoreDBClusterFromSnapshot"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBClusterIdentifier=&SnapshotIdentifier=&Engine=&Action=&Version=#Action=RestoreDBClusterFromSnapshot");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?DBClusterIdentifier=&SnapshotIdentifier=&Engine=&Action=&Version=#Action=RestoreDBClusterFromSnapshot"

	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/?DBClusterIdentifier=&SnapshotIdentifier=&Engine=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?DBClusterIdentifier=&SnapshotIdentifier=&Engine=&Action=&Version=#Action=RestoreDBClusterFromSnapshot")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBClusterIdentifier=&SnapshotIdentifier=&Engine=&Action=&Version=#Action=RestoreDBClusterFromSnapshot"))
    .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}}/?DBClusterIdentifier=&SnapshotIdentifier=&Engine=&Action=&Version=#Action=RestoreDBClusterFromSnapshot")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBClusterIdentifier=&SnapshotIdentifier=&Engine=&Action=&Version=#Action=RestoreDBClusterFromSnapshot")
  .asString();
const 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}}/?DBClusterIdentifier=&SnapshotIdentifier=&Engine=&Action=&Version=#Action=RestoreDBClusterFromSnapshot');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=RestoreDBClusterFromSnapshot',
  params: {
    DBClusterIdentifier: '',
    SnapshotIdentifier: '',
    Engine: '',
    Action: '',
    Version: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBClusterIdentifier=&SnapshotIdentifier=&Engine=&Action=&Version=#Action=RestoreDBClusterFromSnapshot';
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}}/?DBClusterIdentifier=&SnapshotIdentifier=&Engine=&Action=&Version=#Action=RestoreDBClusterFromSnapshot',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?DBClusterIdentifier=&SnapshotIdentifier=&Engine=&Action=&Version=#Action=RestoreDBClusterFromSnapshot")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?DBClusterIdentifier=&SnapshotIdentifier=&Engine=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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=RestoreDBClusterFromSnapshot',
  qs: {
    DBClusterIdentifier: '',
    SnapshotIdentifier: '',
    Engine: '',
    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=RestoreDBClusterFromSnapshot');

req.query({
  DBClusterIdentifier: '',
  SnapshotIdentifier: '',
  Engine: '',
  Action: '',
  Version: ''
});

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=RestoreDBClusterFromSnapshot',
  params: {
    DBClusterIdentifier: '',
    SnapshotIdentifier: '',
    Engine: '',
    Action: '',
    Version: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?DBClusterIdentifier=&SnapshotIdentifier=&Engine=&Action=&Version=#Action=RestoreDBClusterFromSnapshot';
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}}/?DBClusterIdentifier=&SnapshotIdentifier=&Engine=&Action=&Version=#Action=RestoreDBClusterFromSnapshot"]
                                                       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}}/?DBClusterIdentifier=&SnapshotIdentifier=&Engine=&Action=&Version=#Action=RestoreDBClusterFromSnapshot" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBClusterIdentifier=&SnapshotIdentifier=&Engine=&Action=&Version=#Action=RestoreDBClusterFromSnapshot",
  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}}/?DBClusterIdentifier=&SnapshotIdentifier=&Engine=&Action=&Version=#Action=RestoreDBClusterFromSnapshot');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=RestoreDBClusterFromSnapshot');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'DBClusterIdentifier' => '',
  'SnapshotIdentifier' => '',
  'Engine' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=RestoreDBClusterFromSnapshot');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'DBClusterIdentifier' => '',
  'SnapshotIdentifier' => '',
  'Engine' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?DBClusterIdentifier=&SnapshotIdentifier=&Engine=&Action=&Version=#Action=RestoreDBClusterFromSnapshot' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?DBClusterIdentifier=&SnapshotIdentifier=&Engine=&Action=&Version=#Action=RestoreDBClusterFromSnapshot' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?DBClusterIdentifier=&SnapshotIdentifier=&Engine=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=RestoreDBClusterFromSnapshot"

querystring = {"DBClusterIdentifier":"","SnapshotIdentifier":"","Engine":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=RestoreDBClusterFromSnapshot"

queryString <- list(
  DBClusterIdentifier = "",
  SnapshotIdentifier = "",
  Engine = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?DBClusterIdentifier=&SnapshotIdentifier=&Engine=&Action=&Version=#Action=RestoreDBClusterFromSnapshot")

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['DBClusterIdentifier'] = ''
  req.params['SnapshotIdentifier'] = ''
  req.params['Engine'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=RestoreDBClusterFromSnapshot";

    let querystring = [
        ("DBClusterIdentifier", ""),
        ("SnapshotIdentifier", ""),
        ("Engine", ""),
        ("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}}/?DBClusterIdentifier=&SnapshotIdentifier=&Engine=&Action=&Version=#Action=RestoreDBClusterFromSnapshot'
http GET '{{baseUrl}}/?DBClusterIdentifier=&SnapshotIdentifier=&Engine=&Action=&Version=#Action=RestoreDBClusterFromSnapshot'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBClusterIdentifier=&SnapshotIdentifier=&Engine=&Action=&Version=#Action=RestoreDBClusterFromSnapshot'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBClusterIdentifier=&SnapshotIdentifier=&Engine=&Action=&Version=#Action=RestoreDBClusterFromSnapshot")! 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_RestoreDBClusterToPointInTime
{{baseUrl}}/#Action=RestoreDBClusterToPointInTime
QUERY PARAMS
DBClusterIdentifier
SourceDBClusterIdentifier
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?DBClusterIdentifier=&SourceDBClusterIdentifier=&Action=&Version=#Action=RestoreDBClusterToPointInTime");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=RestoreDBClusterToPointInTime" {:query-params {:DBClusterIdentifier ""
                                                                                                :SourceDBClusterIdentifier ""
                                                                                                :Action ""
                                                                                                :Version ""}})
require "http/client"

url = "{{baseUrl}}/?DBClusterIdentifier=&SourceDBClusterIdentifier=&Action=&Version=#Action=RestoreDBClusterToPointInTime"

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}}/?DBClusterIdentifier=&SourceDBClusterIdentifier=&Action=&Version=#Action=RestoreDBClusterToPointInTime"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBClusterIdentifier=&SourceDBClusterIdentifier=&Action=&Version=#Action=RestoreDBClusterToPointInTime");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?DBClusterIdentifier=&SourceDBClusterIdentifier=&Action=&Version=#Action=RestoreDBClusterToPointInTime"

	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/?DBClusterIdentifier=&SourceDBClusterIdentifier=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?DBClusterIdentifier=&SourceDBClusterIdentifier=&Action=&Version=#Action=RestoreDBClusterToPointInTime")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBClusterIdentifier=&SourceDBClusterIdentifier=&Action=&Version=#Action=RestoreDBClusterToPointInTime"))
    .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}}/?DBClusterIdentifier=&SourceDBClusterIdentifier=&Action=&Version=#Action=RestoreDBClusterToPointInTime")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBClusterIdentifier=&SourceDBClusterIdentifier=&Action=&Version=#Action=RestoreDBClusterToPointInTime")
  .asString();
const 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}}/?DBClusterIdentifier=&SourceDBClusterIdentifier=&Action=&Version=#Action=RestoreDBClusterToPointInTime');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=RestoreDBClusterToPointInTime',
  params: {
    DBClusterIdentifier: '',
    SourceDBClusterIdentifier: '',
    Action: '',
    Version: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBClusterIdentifier=&SourceDBClusterIdentifier=&Action=&Version=#Action=RestoreDBClusterToPointInTime';
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}}/?DBClusterIdentifier=&SourceDBClusterIdentifier=&Action=&Version=#Action=RestoreDBClusterToPointInTime',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?DBClusterIdentifier=&SourceDBClusterIdentifier=&Action=&Version=#Action=RestoreDBClusterToPointInTime")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?DBClusterIdentifier=&SourceDBClusterIdentifier=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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=RestoreDBClusterToPointInTime',
  qs: {
    DBClusterIdentifier: '',
    SourceDBClusterIdentifier: '',
    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=RestoreDBClusterToPointInTime');

req.query({
  DBClusterIdentifier: '',
  SourceDBClusterIdentifier: '',
  Action: '',
  Version: ''
});

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=RestoreDBClusterToPointInTime',
  params: {
    DBClusterIdentifier: '',
    SourceDBClusterIdentifier: '',
    Action: '',
    Version: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?DBClusterIdentifier=&SourceDBClusterIdentifier=&Action=&Version=#Action=RestoreDBClusterToPointInTime';
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}}/?DBClusterIdentifier=&SourceDBClusterIdentifier=&Action=&Version=#Action=RestoreDBClusterToPointInTime"]
                                                       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}}/?DBClusterIdentifier=&SourceDBClusterIdentifier=&Action=&Version=#Action=RestoreDBClusterToPointInTime" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBClusterIdentifier=&SourceDBClusterIdentifier=&Action=&Version=#Action=RestoreDBClusterToPointInTime",
  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}}/?DBClusterIdentifier=&SourceDBClusterIdentifier=&Action=&Version=#Action=RestoreDBClusterToPointInTime');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=RestoreDBClusterToPointInTime');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'DBClusterIdentifier' => '',
  'SourceDBClusterIdentifier' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=RestoreDBClusterToPointInTime');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'DBClusterIdentifier' => '',
  'SourceDBClusterIdentifier' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?DBClusterIdentifier=&SourceDBClusterIdentifier=&Action=&Version=#Action=RestoreDBClusterToPointInTime' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?DBClusterIdentifier=&SourceDBClusterIdentifier=&Action=&Version=#Action=RestoreDBClusterToPointInTime' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?DBClusterIdentifier=&SourceDBClusterIdentifier=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=RestoreDBClusterToPointInTime"

querystring = {"DBClusterIdentifier":"","SourceDBClusterIdentifier":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=RestoreDBClusterToPointInTime"

queryString <- list(
  DBClusterIdentifier = "",
  SourceDBClusterIdentifier = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?DBClusterIdentifier=&SourceDBClusterIdentifier=&Action=&Version=#Action=RestoreDBClusterToPointInTime")

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['DBClusterIdentifier'] = ''
  req.params['SourceDBClusterIdentifier'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=RestoreDBClusterToPointInTime";

    let querystring = [
        ("DBClusterIdentifier", ""),
        ("SourceDBClusterIdentifier", ""),
        ("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}}/?DBClusterIdentifier=&SourceDBClusterIdentifier=&Action=&Version=#Action=RestoreDBClusterToPointInTime'
http GET '{{baseUrl}}/?DBClusterIdentifier=&SourceDBClusterIdentifier=&Action=&Version=#Action=RestoreDBClusterToPointInTime'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBClusterIdentifier=&SourceDBClusterIdentifier=&Action=&Version=#Action=RestoreDBClusterToPointInTime'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBClusterIdentifier=&SourceDBClusterIdentifier=&Action=&Version=#Action=RestoreDBClusterToPointInTime")! 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_StartDBCluster
{{baseUrl}}/#Action=StartDBCluster
QUERY PARAMS
DBClusterIdentifier
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StartDBCluster");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=StartDBCluster" {:query-params {:DBClusterIdentifier ""
                                                                                 :Action ""
                                                                                 :Version ""}})
require "http/client"

url = "{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StartDBCluster"

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}}/?DBClusterIdentifier=&Action=&Version=#Action=StartDBCluster"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StartDBCluster");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StartDBCluster"

	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/?DBClusterIdentifier=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StartDBCluster")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StartDBCluster"))
    .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}}/?DBClusterIdentifier=&Action=&Version=#Action=StartDBCluster")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StartDBCluster")
  .asString();
const 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}}/?DBClusterIdentifier=&Action=&Version=#Action=StartDBCluster');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=StartDBCluster',
  params: {DBClusterIdentifier: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StartDBCluster';
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}}/?DBClusterIdentifier=&Action=&Version=#Action=StartDBCluster',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StartDBCluster")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?DBClusterIdentifier=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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=StartDBCluster',
  qs: {DBClusterIdentifier: '', 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=StartDBCluster');

req.query({
  DBClusterIdentifier: '',
  Action: '',
  Version: ''
});

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=StartDBCluster',
  params: {DBClusterIdentifier: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StartDBCluster';
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}}/?DBClusterIdentifier=&Action=&Version=#Action=StartDBCluster"]
                                                       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}}/?DBClusterIdentifier=&Action=&Version=#Action=StartDBCluster" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StartDBCluster",
  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}}/?DBClusterIdentifier=&Action=&Version=#Action=StartDBCluster');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=StartDBCluster');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'DBClusterIdentifier' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=StartDBCluster');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'DBClusterIdentifier' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StartDBCluster' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StartDBCluster' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?DBClusterIdentifier=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=StartDBCluster"

querystring = {"DBClusterIdentifier":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=StartDBCluster"

queryString <- list(
  DBClusterIdentifier = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StartDBCluster")

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['DBClusterIdentifier'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=StartDBCluster";

    let querystring = [
        ("DBClusterIdentifier", ""),
        ("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}}/?DBClusterIdentifier=&Action=&Version=#Action=StartDBCluster'
http GET '{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StartDBCluster'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StartDBCluster'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StartDBCluster")! 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_StopDBCluster
{{baseUrl}}/#Action=StopDBCluster
QUERY PARAMS
DBClusterIdentifier
Action
Version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StopDBCluster");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/#Action=StopDBCluster" {:query-params {:DBClusterIdentifier ""
                                                                                :Action ""
                                                                                :Version ""}})
require "http/client"

url = "{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StopDBCluster"

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}}/?DBClusterIdentifier=&Action=&Version=#Action=StopDBCluster"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StopDBCluster");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StopDBCluster"

	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/?DBClusterIdentifier=&Action=&Version= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StopDBCluster")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StopDBCluster"))
    .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}}/?DBClusterIdentifier=&Action=&Version=#Action=StopDBCluster")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StopDBCluster")
  .asString();
const 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}}/?DBClusterIdentifier=&Action=&Version=#Action=StopDBCluster');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/#Action=StopDBCluster',
  params: {DBClusterIdentifier: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StopDBCluster';
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}}/?DBClusterIdentifier=&Action=&Version=#Action=StopDBCluster',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StopDBCluster")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/?DBClusterIdentifier=&Action=&Version=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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=StopDBCluster',
  qs: {DBClusterIdentifier: '', 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=StopDBCluster');

req.query({
  DBClusterIdentifier: '',
  Action: '',
  Version: ''
});

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=StopDBCluster',
  params: {DBClusterIdentifier: '', Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StopDBCluster';
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}}/?DBClusterIdentifier=&Action=&Version=#Action=StopDBCluster"]
                                                       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}}/?DBClusterIdentifier=&Action=&Version=#Action=StopDBCluster" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StopDBCluster",
  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}}/?DBClusterIdentifier=&Action=&Version=#Action=StopDBCluster');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=StopDBCluster');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'DBClusterIdentifier' => '',
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=StopDBCluster');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'DBClusterIdentifier' => '',
  'Action' => '',
  'Version' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StopDBCluster' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StopDBCluster' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/?DBClusterIdentifier=&Action=&Version=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/#Action=StopDBCluster"

querystring = {"DBClusterIdentifier":"","Action":"","Version":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=StopDBCluster"

queryString <- list(
  DBClusterIdentifier = "",
  Action = "",
  Version = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StopDBCluster")

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['DBClusterIdentifier'] = ''
  req.params['Action'] = ''
  req.params['Version'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#Action=StopDBCluster";

    let querystring = [
        ("DBClusterIdentifier", ""),
        ("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}}/?DBClusterIdentifier=&Action=&Version=#Action=StopDBCluster'
http GET '{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StopDBCluster'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StopDBCluster'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?DBClusterIdentifier=&Action=&Version=#Action=StopDBCluster")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
POST POST_AddRoleToDBCluster
{{baseUrl}}/#Action=AddRoleToDBCluster
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=AddRoleToDBCluster");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=AddRoleToDBCluster" {:query-params {:Action ""
                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=AddRoleToDBCluster"

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=AddRoleToDBCluster"),
};
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=AddRoleToDBCluster");
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=AddRoleToDBCluster"

	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=AddRoleToDBCluster")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=AddRoleToDBCluster"))
    .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=AddRoleToDBCluster")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=AddRoleToDBCluster")
  .asString();
const 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=AddRoleToDBCluster');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=AddRoleToDBCluster',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=AddRoleToDBCluster';
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=AddRoleToDBCluster',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=AddRoleToDBCluster")
  .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=AddRoleToDBCluster',
  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=AddRoleToDBCluster');

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=AddRoleToDBCluster',
  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=AddRoleToDBCluster';
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=AddRoleToDBCluster"]
                                                       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=AddRoleToDBCluster" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=AddRoleToDBCluster",
  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=AddRoleToDBCluster');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=AddRoleToDBCluster');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=AddRoleToDBCluster');
$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=AddRoleToDBCluster' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=AddRoleToDBCluster' -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=AddRoleToDBCluster"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=AddRoleToDBCluster"

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=AddRoleToDBCluster")

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=AddRoleToDBCluster";

    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=AddRoleToDBCluster'
http POST '{{baseUrl}}/?Action=&Version=#Action=AddRoleToDBCluster'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=AddRoleToDBCluster'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=AddRoleToDBCluster")! 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_AddSourceIdentifierToSubscription
{{baseUrl}}/#Action=AddSourceIdentifierToSubscription
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=AddSourceIdentifierToSubscription");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=AddSourceIdentifierToSubscription" {:query-params {:Action ""
                                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=AddSourceIdentifierToSubscription"

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=AddSourceIdentifierToSubscription"),
};
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=AddSourceIdentifierToSubscription");
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=AddSourceIdentifierToSubscription"

	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=AddSourceIdentifierToSubscription")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=AddSourceIdentifierToSubscription"))
    .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=AddSourceIdentifierToSubscription")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=AddSourceIdentifierToSubscription")
  .asString();
const 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=AddSourceIdentifierToSubscription');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=AddSourceIdentifierToSubscription',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=AddSourceIdentifierToSubscription';
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=AddSourceIdentifierToSubscription',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=AddSourceIdentifierToSubscription")
  .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=AddSourceIdentifierToSubscription',
  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=AddSourceIdentifierToSubscription');

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=AddSourceIdentifierToSubscription',
  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=AddSourceIdentifierToSubscription';
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=AddSourceIdentifierToSubscription"]
                                                       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=AddSourceIdentifierToSubscription" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=AddSourceIdentifierToSubscription",
  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=AddSourceIdentifierToSubscription');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=AddSourceIdentifierToSubscription');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=AddSourceIdentifierToSubscription');
$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=AddSourceIdentifierToSubscription' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=AddSourceIdentifierToSubscription' -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=AddSourceIdentifierToSubscription"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=AddSourceIdentifierToSubscription"

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=AddSourceIdentifierToSubscription")

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=AddSourceIdentifierToSubscription";

    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=AddSourceIdentifierToSubscription'
http POST '{{baseUrl}}/?Action=&Version=#Action=AddSourceIdentifierToSubscription'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=AddSourceIdentifierToSubscription'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=AddSourceIdentifierToSubscription")! 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_AddTagsToResource
{{baseUrl}}/#Action=AddTagsToResource
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=AddTagsToResource");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=AddTagsToResource" {:query-params {:Action ""
                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=AddTagsToResource"

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=AddTagsToResource"),
};
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=AddTagsToResource");
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=AddTagsToResource"

	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=AddTagsToResource")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=AddTagsToResource"))
    .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=AddTagsToResource")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=AddTagsToResource")
  .asString();
const 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=AddTagsToResource');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=AddTagsToResource',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=AddTagsToResource';
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=AddTagsToResource',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=AddTagsToResource")
  .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=AddTagsToResource',
  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=AddTagsToResource');

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=AddTagsToResource',
  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=AddTagsToResource';
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=AddTagsToResource"]
                                                       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=AddTagsToResource" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=AddTagsToResource",
  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=AddTagsToResource');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=AddTagsToResource');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=AddTagsToResource');
$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=AddTagsToResource' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=AddTagsToResource' -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=AddTagsToResource"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=AddTagsToResource"

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=AddTagsToResource")

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=AddTagsToResource";

    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=AddTagsToResource'
http POST '{{baseUrl}}/?Action=&Version=#Action=AddTagsToResource'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=AddTagsToResource'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=AddTagsToResource")! 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_ApplyPendingMaintenanceAction
{{baseUrl}}/#Action=ApplyPendingMaintenanceAction
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=ApplyPendingMaintenanceAction");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ApplyPendingMaintenanceAction" {:query-params {:Action ""
                                                                                                 :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ApplyPendingMaintenanceAction"

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=ApplyPendingMaintenanceAction"),
};
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=ApplyPendingMaintenanceAction");
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=ApplyPendingMaintenanceAction"

	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=ApplyPendingMaintenanceAction")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ApplyPendingMaintenanceAction"))
    .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=ApplyPendingMaintenanceAction")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ApplyPendingMaintenanceAction")
  .asString();
const 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=ApplyPendingMaintenanceAction');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ApplyPendingMaintenanceAction',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ApplyPendingMaintenanceAction';
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=ApplyPendingMaintenanceAction',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ApplyPendingMaintenanceAction")
  .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=ApplyPendingMaintenanceAction',
  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=ApplyPendingMaintenanceAction');

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=ApplyPendingMaintenanceAction',
  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=ApplyPendingMaintenanceAction';
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=ApplyPendingMaintenanceAction"]
                                                       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=ApplyPendingMaintenanceAction" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ApplyPendingMaintenanceAction",
  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=ApplyPendingMaintenanceAction');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ApplyPendingMaintenanceAction');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ApplyPendingMaintenanceAction');
$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=ApplyPendingMaintenanceAction' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ApplyPendingMaintenanceAction' -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=ApplyPendingMaintenanceAction"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ApplyPendingMaintenanceAction"

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=ApplyPendingMaintenanceAction")

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=ApplyPendingMaintenanceAction";

    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=ApplyPendingMaintenanceAction'
http POST '{{baseUrl}}/?Action=&Version=#Action=ApplyPendingMaintenanceAction'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ApplyPendingMaintenanceAction'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ApplyPendingMaintenanceAction")! 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_CopyDBClusterParameterGroup
{{baseUrl}}/#Action=CopyDBClusterParameterGroup
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=CopyDBClusterParameterGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=CopyDBClusterParameterGroup" {:query-params {:Action ""
                                                                                               :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=CopyDBClusterParameterGroup"

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=CopyDBClusterParameterGroup"),
};
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=CopyDBClusterParameterGroup");
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=CopyDBClusterParameterGroup"

	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=CopyDBClusterParameterGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=CopyDBClusterParameterGroup"))
    .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=CopyDBClusterParameterGroup")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=CopyDBClusterParameterGroup")
  .asString();
const 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=CopyDBClusterParameterGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CopyDBClusterParameterGroup',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=CopyDBClusterParameterGroup';
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=CopyDBClusterParameterGroup',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=CopyDBClusterParameterGroup")
  .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=CopyDBClusterParameterGroup',
  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=CopyDBClusterParameterGroup');

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=CopyDBClusterParameterGroup',
  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=CopyDBClusterParameterGroup';
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=CopyDBClusterParameterGroup"]
                                                       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=CopyDBClusterParameterGroup" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=CopyDBClusterParameterGroup",
  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=CopyDBClusterParameterGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CopyDBClusterParameterGroup');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CopyDBClusterParameterGroup');
$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=CopyDBClusterParameterGroup' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=CopyDBClusterParameterGroup' -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=CopyDBClusterParameterGroup"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CopyDBClusterParameterGroup"

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=CopyDBClusterParameterGroup")

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=CopyDBClusterParameterGroup";

    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=CopyDBClusterParameterGroup'
http POST '{{baseUrl}}/?Action=&Version=#Action=CopyDBClusterParameterGroup'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=CopyDBClusterParameterGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=CopyDBClusterParameterGroup")! 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_CopyDBClusterSnapshot
{{baseUrl}}/#Action=CopyDBClusterSnapshot
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=CopyDBClusterSnapshot");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=CopyDBClusterSnapshot" {:query-params {:Action ""
                                                                                         :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=CopyDBClusterSnapshot"

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=CopyDBClusterSnapshot"),
};
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=CopyDBClusterSnapshot");
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=CopyDBClusterSnapshot"

	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=CopyDBClusterSnapshot")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=CopyDBClusterSnapshot"))
    .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=CopyDBClusterSnapshot")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=CopyDBClusterSnapshot")
  .asString();
const 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=CopyDBClusterSnapshot');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CopyDBClusterSnapshot',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=CopyDBClusterSnapshot';
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=CopyDBClusterSnapshot',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=CopyDBClusterSnapshot")
  .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=CopyDBClusterSnapshot',
  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=CopyDBClusterSnapshot');

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=CopyDBClusterSnapshot',
  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=CopyDBClusterSnapshot';
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=CopyDBClusterSnapshot"]
                                                       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=CopyDBClusterSnapshot" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=CopyDBClusterSnapshot",
  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=CopyDBClusterSnapshot');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CopyDBClusterSnapshot');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CopyDBClusterSnapshot');
$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=CopyDBClusterSnapshot' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=CopyDBClusterSnapshot' -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=CopyDBClusterSnapshot"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CopyDBClusterSnapshot"

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=CopyDBClusterSnapshot")

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=CopyDBClusterSnapshot";

    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=CopyDBClusterSnapshot'
http POST '{{baseUrl}}/?Action=&Version=#Action=CopyDBClusterSnapshot'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=CopyDBClusterSnapshot'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=CopyDBClusterSnapshot")! 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_CopyDBParameterGroup
{{baseUrl}}/#Action=CopyDBParameterGroup
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=CopyDBParameterGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=CopyDBParameterGroup" {:query-params {:Action ""
                                                                                        :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=CopyDBParameterGroup"

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=CopyDBParameterGroup"),
};
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=CopyDBParameterGroup");
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=CopyDBParameterGroup"

	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=CopyDBParameterGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=CopyDBParameterGroup"))
    .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=CopyDBParameterGroup")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=CopyDBParameterGroup")
  .asString();
const 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=CopyDBParameterGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CopyDBParameterGroup',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=CopyDBParameterGroup';
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=CopyDBParameterGroup',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=CopyDBParameterGroup")
  .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=CopyDBParameterGroup',
  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=CopyDBParameterGroup');

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=CopyDBParameterGroup',
  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=CopyDBParameterGroup';
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=CopyDBParameterGroup"]
                                                       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=CopyDBParameterGroup" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=CopyDBParameterGroup",
  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=CopyDBParameterGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CopyDBParameterGroup');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CopyDBParameterGroup');
$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=CopyDBParameterGroup' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=CopyDBParameterGroup' -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=CopyDBParameterGroup"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CopyDBParameterGroup"

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=CopyDBParameterGroup")

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=CopyDBParameterGroup";

    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=CopyDBParameterGroup'
http POST '{{baseUrl}}/?Action=&Version=#Action=CopyDBParameterGroup'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=CopyDBParameterGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=CopyDBParameterGroup")! 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_CreateDBCluster
{{baseUrl}}/#Action=CreateDBCluster
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=CreateDBCluster");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=CreateDBCluster" {:query-params {:Action ""
                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=CreateDBCluster"

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=CreateDBCluster"),
};
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=CreateDBCluster");
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=CreateDBCluster"

	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=CreateDBCluster")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=CreateDBCluster"))
    .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=CreateDBCluster")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=CreateDBCluster")
  .asString();
const 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=CreateDBCluster');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateDBCluster',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=CreateDBCluster';
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=CreateDBCluster',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=CreateDBCluster")
  .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=CreateDBCluster',
  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=CreateDBCluster');

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=CreateDBCluster',
  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=CreateDBCluster';
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=CreateDBCluster"]
                                                       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=CreateDBCluster" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=CreateDBCluster",
  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=CreateDBCluster');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateDBCluster');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateDBCluster');
$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=CreateDBCluster' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateDBCluster' -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=CreateDBCluster"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateDBCluster"

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=CreateDBCluster")

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=CreateDBCluster";

    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=CreateDBCluster'
http POST '{{baseUrl}}/?Action=&Version=#Action=CreateDBCluster'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=CreateDBCluster'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=CreateDBCluster")! 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_CreateDBClusterEndpoint
{{baseUrl}}/#Action=CreateDBClusterEndpoint
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=CreateDBClusterEndpoint");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=CreateDBClusterEndpoint" {:query-params {:Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterEndpoint"

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=CreateDBClusterEndpoint"),
};
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=CreateDBClusterEndpoint");
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=CreateDBClusterEndpoint"

	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=CreateDBClusterEndpoint")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterEndpoint"))
    .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=CreateDBClusterEndpoint")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterEndpoint")
  .asString();
const 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=CreateDBClusterEndpoint');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateDBClusterEndpoint',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterEndpoint';
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=CreateDBClusterEndpoint',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterEndpoint")
  .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=CreateDBClusterEndpoint',
  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=CreateDBClusterEndpoint');

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=CreateDBClusterEndpoint',
  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=CreateDBClusterEndpoint';
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=CreateDBClusterEndpoint"]
                                                       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=CreateDBClusterEndpoint" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterEndpoint",
  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=CreateDBClusterEndpoint');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateDBClusterEndpoint');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateDBClusterEndpoint');
$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=CreateDBClusterEndpoint' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterEndpoint' -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=CreateDBClusterEndpoint"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateDBClusterEndpoint"

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=CreateDBClusterEndpoint")

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=CreateDBClusterEndpoint";

    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=CreateDBClusterEndpoint'
http POST '{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterEndpoint'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterEndpoint'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterEndpoint")! 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_CreateDBClusterParameterGroup
{{baseUrl}}/#Action=CreateDBClusterParameterGroup
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=CreateDBClusterParameterGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=CreateDBClusterParameterGroup" {:query-params {:Action ""
                                                                                                 :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterParameterGroup"

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=CreateDBClusterParameterGroup"),
};
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=CreateDBClusterParameterGroup");
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=CreateDBClusterParameterGroup"

	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=CreateDBClusterParameterGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterParameterGroup"))
    .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=CreateDBClusterParameterGroup")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterParameterGroup")
  .asString();
const 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=CreateDBClusterParameterGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateDBClusterParameterGroup',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterParameterGroup';
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=CreateDBClusterParameterGroup',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterParameterGroup")
  .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=CreateDBClusterParameterGroup',
  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=CreateDBClusterParameterGroup');

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=CreateDBClusterParameterGroup',
  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=CreateDBClusterParameterGroup';
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=CreateDBClusterParameterGroup"]
                                                       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=CreateDBClusterParameterGroup" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterParameterGroup",
  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=CreateDBClusterParameterGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateDBClusterParameterGroup');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateDBClusterParameterGroup');
$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=CreateDBClusterParameterGroup' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterParameterGroup' -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=CreateDBClusterParameterGroup"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateDBClusterParameterGroup"

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=CreateDBClusterParameterGroup")

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=CreateDBClusterParameterGroup";

    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=CreateDBClusterParameterGroup'
http POST '{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterParameterGroup'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterParameterGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterParameterGroup")! 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_CreateDBClusterSnapshot
{{baseUrl}}/#Action=CreateDBClusterSnapshot
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=CreateDBClusterSnapshot");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=CreateDBClusterSnapshot" {:query-params {:Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterSnapshot"

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=CreateDBClusterSnapshot"),
};
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=CreateDBClusterSnapshot");
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=CreateDBClusterSnapshot"

	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=CreateDBClusterSnapshot")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterSnapshot"))
    .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=CreateDBClusterSnapshot")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterSnapshot")
  .asString();
const 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=CreateDBClusterSnapshot');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateDBClusterSnapshot',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterSnapshot';
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=CreateDBClusterSnapshot',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterSnapshot")
  .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=CreateDBClusterSnapshot',
  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=CreateDBClusterSnapshot');

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=CreateDBClusterSnapshot',
  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=CreateDBClusterSnapshot';
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=CreateDBClusterSnapshot"]
                                                       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=CreateDBClusterSnapshot" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterSnapshot",
  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=CreateDBClusterSnapshot');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateDBClusterSnapshot');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateDBClusterSnapshot');
$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=CreateDBClusterSnapshot' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterSnapshot' -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=CreateDBClusterSnapshot"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateDBClusterSnapshot"

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=CreateDBClusterSnapshot")

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=CreateDBClusterSnapshot";

    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=CreateDBClusterSnapshot'
http POST '{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterSnapshot'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterSnapshot'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=CreateDBClusterSnapshot")! 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_CreateDBInstance
{{baseUrl}}/#Action=CreateDBInstance
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=CreateDBInstance");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=CreateDBInstance" {:query-params {:Action ""
                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=CreateDBInstance"

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=CreateDBInstance"),
};
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=CreateDBInstance");
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=CreateDBInstance"

	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=CreateDBInstance")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=CreateDBInstance"))
    .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=CreateDBInstance")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=CreateDBInstance")
  .asString();
const 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=CreateDBInstance');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateDBInstance',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=CreateDBInstance';
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=CreateDBInstance',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=CreateDBInstance")
  .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=CreateDBInstance',
  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=CreateDBInstance');

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=CreateDBInstance',
  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=CreateDBInstance';
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=CreateDBInstance"]
                                                       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=CreateDBInstance" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=CreateDBInstance",
  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=CreateDBInstance');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateDBInstance');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateDBInstance');
$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=CreateDBInstance' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateDBInstance' -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=CreateDBInstance"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateDBInstance"

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=CreateDBInstance")

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=CreateDBInstance";

    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=CreateDBInstance'
http POST '{{baseUrl}}/?Action=&Version=#Action=CreateDBInstance'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=CreateDBInstance'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=CreateDBInstance")! 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_CreateDBParameterGroup
{{baseUrl}}/#Action=CreateDBParameterGroup
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=CreateDBParameterGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=CreateDBParameterGroup" {:query-params {:Action ""
                                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=CreateDBParameterGroup"

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=CreateDBParameterGroup"),
};
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=CreateDBParameterGroup");
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=CreateDBParameterGroup"

	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=CreateDBParameterGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=CreateDBParameterGroup"))
    .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=CreateDBParameterGroup")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=CreateDBParameterGroup")
  .asString();
const 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=CreateDBParameterGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateDBParameterGroup',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=CreateDBParameterGroup';
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=CreateDBParameterGroup',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=CreateDBParameterGroup")
  .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=CreateDBParameterGroup',
  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=CreateDBParameterGroup');

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=CreateDBParameterGroup',
  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=CreateDBParameterGroup';
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=CreateDBParameterGroup"]
                                                       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=CreateDBParameterGroup" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=CreateDBParameterGroup",
  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=CreateDBParameterGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateDBParameterGroup');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateDBParameterGroup');
$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=CreateDBParameterGroup' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateDBParameterGroup' -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=CreateDBParameterGroup"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateDBParameterGroup"

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=CreateDBParameterGroup")

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=CreateDBParameterGroup";

    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=CreateDBParameterGroup'
http POST '{{baseUrl}}/?Action=&Version=#Action=CreateDBParameterGroup'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=CreateDBParameterGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=CreateDBParameterGroup")! 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_CreateDBSubnetGroup
{{baseUrl}}/#Action=CreateDBSubnetGroup
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=CreateDBSubnetGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=CreateDBSubnetGroup" {:query-params {:Action ""
                                                                                       :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=CreateDBSubnetGroup"

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=CreateDBSubnetGroup"),
};
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=CreateDBSubnetGroup");
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=CreateDBSubnetGroup"

	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=CreateDBSubnetGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=CreateDBSubnetGroup"))
    .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=CreateDBSubnetGroup")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=CreateDBSubnetGroup")
  .asString();
const 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=CreateDBSubnetGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateDBSubnetGroup',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=CreateDBSubnetGroup';
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=CreateDBSubnetGroup',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=CreateDBSubnetGroup")
  .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=CreateDBSubnetGroup',
  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=CreateDBSubnetGroup');

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=CreateDBSubnetGroup',
  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=CreateDBSubnetGroup';
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=CreateDBSubnetGroup"]
                                                       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=CreateDBSubnetGroup" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=CreateDBSubnetGroup",
  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=CreateDBSubnetGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateDBSubnetGroup');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateDBSubnetGroup');
$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=CreateDBSubnetGroup' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateDBSubnetGroup' -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=CreateDBSubnetGroup"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateDBSubnetGroup"

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=CreateDBSubnetGroup")

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=CreateDBSubnetGroup";

    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=CreateDBSubnetGroup'
http POST '{{baseUrl}}/?Action=&Version=#Action=CreateDBSubnetGroup'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=CreateDBSubnetGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=CreateDBSubnetGroup")! 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_CreateEventSubscription
{{baseUrl}}/#Action=CreateEventSubscription
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=CreateEventSubscription");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=CreateEventSubscription" {:query-params {:Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=CreateEventSubscription"

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=CreateEventSubscription"),
};
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=CreateEventSubscription");
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=CreateEventSubscription"

	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=CreateEventSubscription")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=CreateEventSubscription"))
    .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=CreateEventSubscription")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=CreateEventSubscription")
  .asString();
const 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=CreateEventSubscription');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateEventSubscription',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=CreateEventSubscription';
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=CreateEventSubscription',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=CreateEventSubscription")
  .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=CreateEventSubscription',
  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=CreateEventSubscription');

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=CreateEventSubscription',
  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=CreateEventSubscription';
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=CreateEventSubscription"]
                                                       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=CreateEventSubscription" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=CreateEventSubscription",
  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=CreateEventSubscription');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateEventSubscription');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateEventSubscription');
$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=CreateEventSubscription' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateEventSubscription' -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=CreateEventSubscription"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateEventSubscription"

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=CreateEventSubscription")

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=CreateEventSubscription";

    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=CreateEventSubscription'
http POST '{{baseUrl}}/?Action=&Version=#Action=CreateEventSubscription'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=CreateEventSubscription'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=CreateEventSubscription")! 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_CreateGlobalCluster
{{baseUrl}}/#Action=CreateGlobalCluster
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=CreateGlobalCluster");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=CreateGlobalCluster" {:query-params {:Action ""
                                                                                       :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=CreateGlobalCluster"

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=CreateGlobalCluster"),
};
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=CreateGlobalCluster");
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=CreateGlobalCluster"

	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=CreateGlobalCluster")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=CreateGlobalCluster"))
    .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=CreateGlobalCluster")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=CreateGlobalCluster")
  .asString();
const 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=CreateGlobalCluster');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=CreateGlobalCluster',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=CreateGlobalCluster';
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=CreateGlobalCluster',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=CreateGlobalCluster")
  .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=CreateGlobalCluster',
  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=CreateGlobalCluster');

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=CreateGlobalCluster',
  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=CreateGlobalCluster';
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=CreateGlobalCluster"]
                                                       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=CreateGlobalCluster" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=CreateGlobalCluster",
  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=CreateGlobalCluster');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=CreateGlobalCluster');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=CreateGlobalCluster');
$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=CreateGlobalCluster' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=CreateGlobalCluster' -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=CreateGlobalCluster"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=CreateGlobalCluster"

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=CreateGlobalCluster")

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=CreateGlobalCluster";

    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=CreateGlobalCluster'
http POST '{{baseUrl}}/?Action=&Version=#Action=CreateGlobalCluster'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=CreateGlobalCluster'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=CreateGlobalCluster")! 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_DeleteDBCluster
{{baseUrl}}/#Action=DeleteDBCluster
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=DeleteDBCluster");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteDBCluster" {:query-params {:Action ""
                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteDBCluster"

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=DeleteDBCluster"),
};
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=DeleteDBCluster");
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=DeleteDBCluster"

	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=DeleteDBCluster")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteDBCluster"))
    .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=DeleteDBCluster")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteDBCluster")
  .asString();
const 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=DeleteDBCluster');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteDBCluster',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteDBCluster';
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=DeleteDBCluster',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteDBCluster")
  .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=DeleteDBCluster',
  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=DeleteDBCluster');

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=DeleteDBCluster',
  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=DeleteDBCluster';
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=DeleteDBCluster"]
                                                       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=DeleteDBCluster" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteDBCluster",
  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=DeleteDBCluster');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteDBCluster');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteDBCluster');
$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=DeleteDBCluster' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteDBCluster' -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=DeleteDBCluster"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteDBCluster"

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=DeleteDBCluster")

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=DeleteDBCluster";

    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=DeleteDBCluster'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteDBCluster'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteDBCluster'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteDBCluster")! 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_DeleteDBClusterEndpoint
{{baseUrl}}/#Action=DeleteDBClusterEndpoint
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=DeleteDBClusterEndpoint");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteDBClusterEndpoint" {:query-params {:Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterEndpoint"

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=DeleteDBClusterEndpoint"),
};
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=DeleteDBClusterEndpoint");
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=DeleteDBClusterEndpoint"

	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=DeleteDBClusterEndpoint")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterEndpoint"))
    .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=DeleteDBClusterEndpoint")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterEndpoint")
  .asString();
const 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=DeleteDBClusterEndpoint');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteDBClusterEndpoint',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterEndpoint';
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=DeleteDBClusterEndpoint',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterEndpoint")
  .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=DeleteDBClusterEndpoint',
  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=DeleteDBClusterEndpoint');

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=DeleteDBClusterEndpoint',
  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=DeleteDBClusterEndpoint';
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=DeleteDBClusterEndpoint"]
                                                       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=DeleteDBClusterEndpoint" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterEndpoint",
  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=DeleteDBClusterEndpoint');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteDBClusterEndpoint');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteDBClusterEndpoint');
$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=DeleteDBClusterEndpoint' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterEndpoint' -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=DeleteDBClusterEndpoint"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteDBClusterEndpoint"

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=DeleteDBClusterEndpoint")

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=DeleteDBClusterEndpoint";

    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=DeleteDBClusterEndpoint'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterEndpoint'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterEndpoint'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterEndpoint")! 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_DeleteDBClusterParameterGroup
{{baseUrl}}/#Action=DeleteDBClusterParameterGroup
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=DeleteDBClusterParameterGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteDBClusterParameterGroup" {:query-params {:Action ""
                                                                                                 :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterParameterGroup"

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=DeleteDBClusterParameterGroup"),
};
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=DeleteDBClusterParameterGroup");
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=DeleteDBClusterParameterGroup"

	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=DeleteDBClusterParameterGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterParameterGroup"))
    .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=DeleteDBClusterParameterGroup")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterParameterGroup")
  .asString();
const 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=DeleteDBClusterParameterGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteDBClusterParameterGroup',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterParameterGroup';
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=DeleteDBClusterParameterGroup',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterParameterGroup")
  .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=DeleteDBClusterParameterGroup',
  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=DeleteDBClusterParameterGroup');

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=DeleteDBClusterParameterGroup',
  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=DeleteDBClusterParameterGroup';
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=DeleteDBClusterParameterGroup"]
                                                       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=DeleteDBClusterParameterGroup" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterParameterGroup",
  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=DeleteDBClusterParameterGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteDBClusterParameterGroup');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteDBClusterParameterGroup');
$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=DeleteDBClusterParameterGroup' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterParameterGroup' -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=DeleteDBClusterParameterGroup"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteDBClusterParameterGroup"

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=DeleteDBClusterParameterGroup")

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=DeleteDBClusterParameterGroup";

    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=DeleteDBClusterParameterGroup'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterParameterGroup'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterParameterGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterParameterGroup")! 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_DeleteDBClusterSnapshot
{{baseUrl}}/#Action=DeleteDBClusterSnapshot
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=DeleteDBClusterSnapshot");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteDBClusterSnapshot" {:query-params {:Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterSnapshot"

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=DeleteDBClusterSnapshot"),
};
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=DeleteDBClusterSnapshot");
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=DeleteDBClusterSnapshot"

	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=DeleteDBClusterSnapshot")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterSnapshot"))
    .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=DeleteDBClusterSnapshot")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterSnapshot")
  .asString();
const 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=DeleteDBClusterSnapshot');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteDBClusterSnapshot',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterSnapshot';
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=DeleteDBClusterSnapshot',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterSnapshot")
  .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=DeleteDBClusterSnapshot',
  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=DeleteDBClusterSnapshot');

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=DeleteDBClusterSnapshot',
  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=DeleteDBClusterSnapshot';
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=DeleteDBClusterSnapshot"]
                                                       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=DeleteDBClusterSnapshot" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterSnapshot",
  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=DeleteDBClusterSnapshot');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteDBClusterSnapshot');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteDBClusterSnapshot');
$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=DeleteDBClusterSnapshot' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterSnapshot' -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=DeleteDBClusterSnapshot"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteDBClusterSnapshot"

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=DeleteDBClusterSnapshot")

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=DeleteDBClusterSnapshot";

    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=DeleteDBClusterSnapshot'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterSnapshot'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterSnapshot'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteDBClusterSnapshot")! 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_DeleteDBInstance
{{baseUrl}}/#Action=DeleteDBInstance
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=DeleteDBInstance");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteDBInstance" {:query-params {:Action ""
                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteDBInstance"

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=DeleteDBInstance"),
};
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=DeleteDBInstance");
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=DeleteDBInstance"

	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=DeleteDBInstance")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteDBInstance"))
    .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=DeleteDBInstance")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteDBInstance")
  .asString();
const 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=DeleteDBInstance');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteDBInstance',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteDBInstance';
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=DeleteDBInstance',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteDBInstance")
  .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=DeleteDBInstance',
  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=DeleteDBInstance');

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=DeleteDBInstance',
  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=DeleteDBInstance';
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=DeleteDBInstance"]
                                                       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=DeleteDBInstance" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteDBInstance",
  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=DeleteDBInstance');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteDBInstance');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteDBInstance');
$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=DeleteDBInstance' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteDBInstance' -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=DeleteDBInstance"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteDBInstance"

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=DeleteDBInstance")

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=DeleteDBInstance";

    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=DeleteDBInstance'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteDBInstance'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteDBInstance'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteDBInstance")! 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_DeleteDBParameterGroup
{{baseUrl}}/#Action=DeleteDBParameterGroup
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=DeleteDBParameterGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteDBParameterGroup" {:query-params {:Action ""
                                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteDBParameterGroup"

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=DeleteDBParameterGroup"),
};
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=DeleteDBParameterGroup");
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=DeleteDBParameterGroup"

	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=DeleteDBParameterGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteDBParameterGroup"))
    .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=DeleteDBParameterGroup")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteDBParameterGroup")
  .asString();
const 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=DeleteDBParameterGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteDBParameterGroup',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteDBParameterGroup';
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=DeleteDBParameterGroup',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteDBParameterGroup")
  .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=DeleteDBParameterGroup',
  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=DeleteDBParameterGroup');

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=DeleteDBParameterGroup',
  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=DeleteDBParameterGroup';
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=DeleteDBParameterGroup"]
                                                       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=DeleteDBParameterGroup" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteDBParameterGroup",
  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=DeleteDBParameterGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteDBParameterGroup');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteDBParameterGroup');
$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=DeleteDBParameterGroup' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteDBParameterGroup' -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=DeleteDBParameterGroup"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteDBParameterGroup"

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=DeleteDBParameterGroup")

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=DeleteDBParameterGroup";

    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=DeleteDBParameterGroup'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteDBParameterGroup'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteDBParameterGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteDBParameterGroup")! 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_DeleteDBSubnetGroup
{{baseUrl}}/#Action=DeleteDBSubnetGroup
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=DeleteDBSubnetGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteDBSubnetGroup" {:query-params {:Action ""
                                                                                       :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteDBSubnetGroup"

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=DeleteDBSubnetGroup"),
};
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=DeleteDBSubnetGroup");
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=DeleteDBSubnetGroup"

	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=DeleteDBSubnetGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteDBSubnetGroup"))
    .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=DeleteDBSubnetGroup")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteDBSubnetGroup")
  .asString();
const 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=DeleteDBSubnetGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteDBSubnetGroup',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteDBSubnetGroup';
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=DeleteDBSubnetGroup',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteDBSubnetGroup")
  .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=DeleteDBSubnetGroup',
  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=DeleteDBSubnetGroup');

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=DeleteDBSubnetGroup',
  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=DeleteDBSubnetGroup';
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=DeleteDBSubnetGroup"]
                                                       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=DeleteDBSubnetGroup" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteDBSubnetGroup",
  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=DeleteDBSubnetGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteDBSubnetGroup');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteDBSubnetGroup');
$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=DeleteDBSubnetGroup' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteDBSubnetGroup' -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=DeleteDBSubnetGroup"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteDBSubnetGroup"

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=DeleteDBSubnetGroup")

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=DeleteDBSubnetGroup";

    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=DeleteDBSubnetGroup'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteDBSubnetGroup'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteDBSubnetGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteDBSubnetGroup")! 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_DeleteEventSubscription
{{baseUrl}}/#Action=DeleteEventSubscription
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=DeleteEventSubscription");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteEventSubscription" {:query-params {:Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteEventSubscription"

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=DeleteEventSubscription"),
};
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=DeleteEventSubscription");
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=DeleteEventSubscription"

	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=DeleteEventSubscription")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteEventSubscription"))
    .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=DeleteEventSubscription")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteEventSubscription")
  .asString();
const 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=DeleteEventSubscription');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteEventSubscription',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteEventSubscription';
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=DeleteEventSubscription',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteEventSubscription")
  .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=DeleteEventSubscription',
  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=DeleteEventSubscription');

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=DeleteEventSubscription',
  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=DeleteEventSubscription';
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=DeleteEventSubscription"]
                                                       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=DeleteEventSubscription" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteEventSubscription",
  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=DeleteEventSubscription');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteEventSubscription');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteEventSubscription');
$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=DeleteEventSubscription' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteEventSubscription' -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=DeleteEventSubscription"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteEventSubscription"

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=DeleteEventSubscription")

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=DeleteEventSubscription";

    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=DeleteEventSubscription'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteEventSubscription'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteEventSubscription'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteEventSubscription")! 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_DeleteGlobalCluster
{{baseUrl}}/#Action=DeleteGlobalCluster
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=DeleteGlobalCluster");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DeleteGlobalCluster" {:query-params {:Action ""
                                                                                       :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DeleteGlobalCluster"

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=DeleteGlobalCluster"),
};
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=DeleteGlobalCluster");
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=DeleteGlobalCluster"

	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=DeleteGlobalCluster")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DeleteGlobalCluster"))
    .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=DeleteGlobalCluster")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DeleteGlobalCluster")
  .asString();
const 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=DeleteGlobalCluster');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DeleteGlobalCluster',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DeleteGlobalCluster';
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=DeleteGlobalCluster',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DeleteGlobalCluster")
  .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=DeleteGlobalCluster',
  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=DeleteGlobalCluster');

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=DeleteGlobalCluster',
  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=DeleteGlobalCluster';
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=DeleteGlobalCluster"]
                                                       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=DeleteGlobalCluster" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DeleteGlobalCluster",
  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=DeleteGlobalCluster');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DeleteGlobalCluster');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DeleteGlobalCluster');
$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=DeleteGlobalCluster' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DeleteGlobalCluster' -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=DeleteGlobalCluster"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DeleteGlobalCluster"

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=DeleteGlobalCluster")

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=DeleteGlobalCluster";

    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=DeleteGlobalCluster'
http POST '{{baseUrl}}/?Action=&Version=#Action=DeleteGlobalCluster'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DeleteGlobalCluster'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DeleteGlobalCluster")! 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_DescribeDBClusterEndpoints
{{baseUrl}}/#Action=DescribeDBClusterEndpoints
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=DescribeDBClusterEndpoints");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DescribeDBClusterEndpoints" {:query-params {:Action ""
                                                                                              :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterEndpoints"

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=DescribeDBClusterEndpoints"),
};
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=DescribeDBClusterEndpoints");
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=DescribeDBClusterEndpoints"

	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=DescribeDBClusterEndpoints")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterEndpoints"))
    .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=DescribeDBClusterEndpoints")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterEndpoints")
  .asString();
const 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=DescribeDBClusterEndpoints');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DescribeDBClusterEndpoints',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterEndpoints';
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=DescribeDBClusterEndpoints',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterEndpoints")
  .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=DescribeDBClusterEndpoints',
  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=DescribeDBClusterEndpoints');

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=DescribeDBClusterEndpoints',
  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=DescribeDBClusterEndpoints';
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=DescribeDBClusterEndpoints"]
                                                       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=DescribeDBClusterEndpoints" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterEndpoints",
  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=DescribeDBClusterEndpoints');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeDBClusterEndpoints');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeDBClusterEndpoints');
$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=DescribeDBClusterEndpoints' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterEndpoints' -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=DescribeDBClusterEndpoints"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeDBClusterEndpoints"

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=DescribeDBClusterEndpoints")

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=DescribeDBClusterEndpoints";

    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=DescribeDBClusterEndpoints'
http POST '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterEndpoints'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterEndpoints'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterEndpoints")! 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_DescribeDBClusterParameterGroups
{{baseUrl}}/#Action=DescribeDBClusterParameterGroups
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=DescribeDBClusterParameterGroups");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DescribeDBClusterParameterGroups" {:query-params {:Action ""
                                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameterGroups"

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=DescribeDBClusterParameterGroups"),
};
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=DescribeDBClusterParameterGroups");
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=DescribeDBClusterParameterGroups"

	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=DescribeDBClusterParameterGroups")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameterGroups"))
    .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=DescribeDBClusterParameterGroups")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameterGroups")
  .asString();
const 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=DescribeDBClusterParameterGroups');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DescribeDBClusterParameterGroups',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameterGroups';
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=DescribeDBClusterParameterGroups',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameterGroups")
  .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=DescribeDBClusterParameterGroups',
  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=DescribeDBClusterParameterGroups');

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=DescribeDBClusterParameterGroups',
  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=DescribeDBClusterParameterGroups';
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=DescribeDBClusterParameterGroups"]
                                                       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=DescribeDBClusterParameterGroups" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameterGroups",
  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=DescribeDBClusterParameterGroups');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeDBClusterParameterGroups');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeDBClusterParameterGroups');
$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=DescribeDBClusterParameterGroups' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameterGroups' -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=DescribeDBClusterParameterGroups"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeDBClusterParameterGroups"

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=DescribeDBClusterParameterGroups")

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=DescribeDBClusterParameterGroups";

    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=DescribeDBClusterParameterGroups'
http POST '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameterGroups'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameterGroups'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameterGroups")! 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_DescribeDBClusterParameters
{{baseUrl}}/#Action=DescribeDBClusterParameters
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=DescribeDBClusterParameters");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DescribeDBClusterParameters" {:query-params {:Action ""
                                                                                               :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameters"

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=DescribeDBClusterParameters"),
};
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=DescribeDBClusterParameters");
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=DescribeDBClusterParameters"

	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=DescribeDBClusterParameters")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameters"))
    .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=DescribeDBClusterParameters")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameters")
  .asString();
const 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=DescribeDBClusterParameters');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DescribeDBClusterParameters',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameters';
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=DescribeDBClusterParameters',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameters")
  .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=DescribeDBClusterParameters',
  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=DescribeDBClusterParameters');

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=DescribeDBClusterParameters',
  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=DescribeDBClusterParameters';
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=DescribeDBClusterParameters"]
                                                       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=DescribeDBClusterParameters" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameters",
  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=DescribeDBClusterParameters');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeDBClusterParameters');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeDBClusterParameters');
$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=DescribeDBClusterParameters' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameters' -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=DescribeDBClusterParameters"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeDBClusterParameters"

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=DescribeDBClusterParameters")

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=DescribeDBClusterParameters";

    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=DescribeDBClusterParameters'
http POST '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameters'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameters'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterParameters")! 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_DescribeDBClusterSnapshotAttributes
{{baseUrl}}/#Action=DescribeDBClusterSnapshotAttributes
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=DescribeDBClusterSnapshotAttributes");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DescribeDBClusterSnapshotAttributes" {:query-params {:Action ""
                                                                                                       :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshotAttributes"

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=DescribeDBClusterSnapshotAttributes"),
};
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=DescribeDBClusterSnapshotAttributes");
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=DescribeDBClusterSnapshotAttributes"

	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=DescribeDBClusterSnapshotAttributes")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshotAttributes"))
    .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=DescribeDBClusterSnapshotAttributes")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshotAttributes")
  .asString();
const 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=DescribeDBClusterSnapshotAttributes');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DescribeDBClusterSnapshotAttributes',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshotAttributes';
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=DescribeDBClusterSnapshotAttributes',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshotAttributes")
  .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=DescribeDBClusterSnapshotAttributes',
  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=DescribeDBClusterSnapshotAttributes');

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=DescribeDBClusterSnapshotAttributes',
  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=DescribeDBClusterSnapshotAttributes';
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=DescribeDBClusterSnapshotAttributes"]
                                                       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=DescribeDBClusterSnapshotAttributes" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshotAttributes",
  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=DescribeDBClusterSnapshotAttributes');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeDBClusterSnapshotAttributes');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeDBClusterSnapshotAttributes');
$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=DescribeDBClusterSnapshotAttributes' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshotAttributes' -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=DescribeDBClusterSnapshotAttributes"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeDBClusterSnapshotAttributes"

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=DescribeDBClusterSnapshotAttributes")

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=DescribeDBClusterSnapshotAttributes";

    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=DescribeDBClusterSnapshotAttributes'
http POST '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshotAttributes'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshotAttributes'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshotAttributes")! 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_DescribeDBClusterSnapshots
{{baseUrl}}/#Action=DescribeDBClusterSnapshots
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=DescribeDBClusterSnapshots");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DescribeDBClusterSnapshots" {:query-params {:Action ""
                                                                                              :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshots"

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=DescribeDBClusterSnapshots"),
};
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=DescribeDBClusterSnapshots");
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=DescribeDBClusterSnapshots"

	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=DescribeDBClusterSnapshots")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshots"))
    .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=DescribeDBClusterSnapshots")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshots")
  .asString();
const 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=DescribeDBClusterSnapshots');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DescribeDBClusterSnapshots',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshots';
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=DescribeDBClusterSnapshots',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshots")
  .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=DescribeDBClusterSnapshots',
  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=DescribeDBClusterSnapshots');

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=DescribeDBClusterSnapshots',
  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=DescribeDBClusterSnapshots';
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=DescribeDBClusterSnapshots"]
                                                       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=DescribeDBClusterSnapshots" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshots",
  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=DescribeDBClusterSnapshots');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeDBClusterSnapshots');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeDBClusterSnapshots');
$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=DescribeDBClusterSnapshots' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshots' -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=DescribeDBClusterSnapshots"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeDBClusterSnapshots"

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=DescribeDBClusterSnapshots")

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=DescribeDBClusterSnapshots";

    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=DescribeDBClusterSnapshots'
http POST '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshots'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshots'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusterSnapshots")! 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_DescribeDBClusters
{{baseUrl}}/#Action=DescribeDBClusters
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=DescribeDBClusters");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DescribeDBClusters" {:query-params {:Action ""
                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusters"

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=DescribeDBClusters"),
};
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=DescribeDBClusters");
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=DescribeDBClusters"

	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=DescribeDBClusters")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusters"))
    .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=DescribeDBClusters")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusters")
  .asString();
const 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=DescribeDBClusters');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DescribeDBClusters',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusters';
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=DescribeDBClusters',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusters")
  .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=DescribeDBClusters',
  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=DescribeDBClusters');

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=DescribeDBClusters',
  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=DescribeDBClusters';
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=DescribeDBClusters"]
                                                       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=DescribeDBClusters" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusters",
  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=DescribeDBClusters');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeDBClusters');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeDBClusters');
$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=DescribeDBClusters' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusters' -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=DescribeDBClusters"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeDBClusters"

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=DescribeDBClusters")

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=DescribeDBClusters";

    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=DescribeDBClusters'
http POST '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusters'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusters'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeDBClusters")! 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_DescribeDBEngineVersions
{{baseUrl}}/#Action=DescribeDBEngineVersions
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=DescribeDBEngineVersions");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DescribeDBEngineVersions" {:query-params {:Action ""
                                                                                            :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeDBEngineVersions"

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=DescribeDBEngineVersions"),
};
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=DescribeDBEngineVersions");
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=DescribeDBEngineVersions"

	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=DescribeDBEngineVersions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeDBEngineVersions"))
    .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=DescribeDBEngineVersions")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DescribeDBEngineVersions")
  .asString();
const 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=DescribeDBEngineVersions');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DescribeDBEngineVersions',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeDBEngineVersions';
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=DescribeDBEngineVersions',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeDBEngineVersions")
  .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=DescribeDBEngineVersions',
  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=DescribeDBEngineVersions');

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=DescribeDBEngineVersions',
  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=DescribeDBEngineVersions';
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=DescribeDBEngineVersions"]
                                                       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=DescribeDBEngineVersions" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeDBEngineVersions",
  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=DescribeDBEngineVersions');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeDBEngineVersions');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeDBEngineVersions');
$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=DescribeDBEngineVersions' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeDBEngineVersions' -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=DescribeDBEngineVersions"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeDBEngineVersions"

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=DescribeDBEngineVersions")

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=DescribeDBEngineVersions";

    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=DescribeDBEngineVersions'
http POST '{{baseUrl}}/?Action=&Version=#Action=DescribeDBEngineVersions'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeDBEngineVersions'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeDBEngineVersions")! 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_DescribeDBInstances
{{baseUrl}}/#Action=DescribeDBInstances
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=DescribeDBInstances");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DescribeDBInstances" {:query-params {:Action ""
                                                                                       :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeDBInstances"

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=DescribeDBInstances"),
};
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=DescribeDBInstances");
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=DescribeDBInstances"

	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=DescribeDBInstances")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeDBInstances"))
    .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=DescribeDBInstances")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DescribeDBInstances")
  .asString();
const 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=DescribeDBInstances');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DescribeDBInstances',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeDBInstances';
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=DescribeDBInstances',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeDBInstances")
  .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=DescribeDBInstances',
  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=DescribeDBInstances');

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=DescribeDBInstances',
  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=DescribeDBInstances';
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=DescribeDBInstances"]
                                                       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=DescribeDBInstances" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeDBInstances",
  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=DescribeDBInstances');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeDBInstances');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeDBInstances');
$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=DescribeDBInstances' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeDBInstances' -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=DescribeDBInstances"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeDBInstances"

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=DescribeDBInstances")

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=DescribeDBInstances";

    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=DescribeDBInstances'
http POST '{{baseUrl}}/?Action=&Version=#Action=DescribeDBInstances'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeDBInstances'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeDBInstances")! 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_DescribeDBParameterGroups
{{baseUrl}}/#Action=DescribeDBParameterGroups
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=DescribeDBParameterGroups");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DescribeDBParameterGroups" {:query-params {:Action ""
                                                                                             :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameterGroups"

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=DescribeDBParameterGroups"),
};
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=DescribeDBParameterGroups");
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=DescribeDBParameterGroups"

	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=DescribeDBParameterGroups")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameterGroups"))
    .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=DescribeDBParameterGroups")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameterGroups")
  .asString();
const 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=DescribeDBParameterGroups');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DescribeDBParameterGroups',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameterGroups';
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=DescribeDBParameterGroups',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameterGroups")
  .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=DescribeDBParameterGroups',
  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=DescribeDBParameterGroups');

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=DescribeDBParameterGroups',
  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=DescribeDBParameterGroups';
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=DescribeDBParameterGroups"]
                                                       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=DescribeDBParameterGroups" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameterGroups",
  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=DescribeDBParameterGroups');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeDBParameterGroups');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeDBParameterGroups');
$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=DescribeDBParameterGroups' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameterGroups' -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=DescribeDBParameterGroups"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeDBParameterGroups"

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=DescribeDBParameterGroups")

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=DescribeDBParameterGroups";

    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=DescribeDBParameterGroups'
http POST '{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameterGroups'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameterGroups'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameterGroups")! 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_DescribeDBParameters
{{baseUrl}}/#Action=DescribeDBParameters
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=DescribeDBParameters");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DescribeDBParameters" {:query-params {:Action ""
                                                                                        :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameters"

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=DescribeDBParameters"),
};
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=DescribeDBParameters");
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=DescribeDBParameters"

	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=DescribeDBParameters")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameters"))
    .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=DescribeDBParameters")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameters")
  .asString();
const 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=DescribeDBParameters');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DescribeDBParameters',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameters';
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=DescribeDBParameters',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameters")
  .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=DescribeDBParameters',
  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=DescribeDBParameters');

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=DescribeDBParameters',
  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=DescribeDBParameters';
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=DescribeDBParameters"]
                                                       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=DescribeDBParameters" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameters",
  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=DescribeDBParameters');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeDBParameters');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeDBParameters');
$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=DescribeDBParameters' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameters' -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=DescribeDBParameters"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeDBParameters"

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=DescribeDBParameters")

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=DescribeDBParameters";

    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=DescribeDBParameters'
http POST '{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameters'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameters'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeDBParameters")! 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_DescribeDBSubnetGroups
{{baseUrl}}/#Action=DescribeDBSubnetGroups
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=DescribeDBSubnetGroups");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DescribeDBSubnetGroups" {:query-params {:Action ""
                                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeDBSubnetGroups"

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=DescribeDBSubnetGroups"),
};
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=DescribeDBSubnetGroups");
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=DescribeDBSubnetGroups"

	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=DescribeDBSubnetGroups")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeDBSubnetGroups"))
    .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=DescribeDBSubnetGroups")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DescribeDBSubnetGroups")
  .asString();
const 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=DescribeDBSubnetGroups');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DescribeDBSubnetGroups',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeDBSubnetGroups';
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=DescribeDBSubnetGroups',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeDBSubnetGroups")
  .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=DescribeDBSubnetGroups',
  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=DescribeDBSubnetGroups');

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=DescribeDBSubnetGroups',
  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=DescribeDBSubnetGroups';
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=DescribeDBSubnetGroups"]
                                                       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=DescribeDBSubnetGroups" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeDBSubnetGroups",
  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=DescribeDBSubnetGroups');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeDBSubnetGroups');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeDBSubnetGroups');
$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=DescribeDBSubnetGroups' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeDBSubnetGroups' -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=DescribeDBSubnetGroups"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeDBSubnetGroups"

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=DescribeDBSubnetGroups")

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=DescribeDBSubnetGroups";

    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=DescribeDBSubnetGroups'
http POST '{{baseUrl}}/?Action=&Version=#Action=DescribeDBSubnetGroups'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeDBSubnetGroups'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeDBSubnetGroups")! 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_DescribeEngineDefaultClusterParameters
{{baseUrl}}/#Action=DescribeEngineDefaultClusterParameters
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=DescribeEngineDefaultClusterParameters");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DescribeEngineDefaultClusterParameters" {:query-params {:Action ""
                                                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeEngineDefaultClusterParameters"

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=DescribeEngineDefaultClusterParameters"),
};
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=DescribeEngineDefaultClusterParameters");
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=DescribeEngineDefaultClusterParameters"

	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=DescribeEngineDefaultClusterParameters")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeEngineDefaultClusterParameters"))
    .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=DescribeEngineDefaultClusterParameters")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DescribeEngineDefaultClusterParameters")
  .asString();
const 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=DescribeEngineDefaultClusterParameters');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DescribeEngineDefaultClusterParameters',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeEngineDefaultClusterParameters';
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=DescribeEngineDefaultClusterParameters',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeEngineDefaultClusterParameters")
  .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=DescribeEngineDefaultClusterParameters',
  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=DescribeEngineDefaultClusterParameters');

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=DescribeEngineDefaultClusterParameters',
  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=DescribeEngineDefaultClusterParameters';
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=DescribeEngineDefaultClusterParameters"]
                                                       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=DescribeEngineDefaultClusterParameters" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeEngineDefaultClusterParameters",
  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=DescribeEngineDefaultClusterParameters');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeEngineDefaultClusterParameters');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeEngineDefaultClusterParameters');
$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=DescribeEngineDefaultClusterParameters' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeEngineDefaultClusterParameters' -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=DescribeEngineDefaultClusterParameters"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeEngineDefaultClusterParameters"

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=DescribeEngineDefaultClusterParameters")

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=DescribeEngineDefaultClusterParameters";

    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=DescribeEngineDefaultClusterParameters'
http POST '{{baseUrl}}/?Action=&Version=#Action=DescribeEngineDefaultClusterParameters'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeEngineDefaultClusterParameters'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeEngineDefaultClusterParameters")! 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_DescribeEngineDefaultParameters
{{baseUrl}}/#Action=DescribeEngineDefaultParameters
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=DescribeEngineDefaultParameters");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DescribeEngineDefaultParameters" {:query-params {:Action ""
                                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeEngineDefaultParameters"

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=DescribeEngineDefaultParameters"),
};
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=DescribeEngineDefaultParameters");
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=DescribeEngineDefaultParameters"

	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=DescribeEngineDefaultParameters")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeEngineDefaultParameters"))
    .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=DescribeEngineDefaultParameters")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DescribeEngineDefaultParameters")
  .asString();
const 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=DescribeEngineDefaultParameters');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DescribeEngineDefaultParameters',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeEngineDefaultParameters';
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=DescribeEngineDefaultParameters',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeEngineDefaultParameters")
  .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=DescribeEngineDefaultParameters',
  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=DescribeEngineDefaultParameters');

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=DescribeEngineDefaultParameters',
  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=DescribeEngineDefaultParameters';
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=DescribeEngineDefaultParameters"]
                                                       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=DescribeEngineDefaultParameters" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeEngineDefaultParameters",
  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=DescribeEngineDefaultParameters');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeEngineDefaultParameters');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeEngineDefaultParameters');
$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=DescribeEngineDefaultParameters' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeEngineDefaultParameters' -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=DescribeEngineDefaultParameters"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeEngineDefaultParameters"

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=DescribeEngineDefaultParameters")

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=DescribeEngineDefaultParameters";

    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=DescribeEngineDefaultParameters'
http POST '{{baseUrl}}/?Action=&Version=#Action=DescribeEngineDefaultParameters'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeEngineDefaultParameters'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeEngineDefaultParameters")! 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_DescribeEventCategories
{{baseUrl}}/#Action=DescribeEventCategories
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=DescribeEventCategories");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DescribeEventCategories" {:query-params {:Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeEventCategories"

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=DescribeEventCategories"),
};
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=DescribeEventCategories");
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=DescribeEventCategories"

	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=DescribeEventCategories")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeEventCategories"))
    .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=DescribeEventCategories")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DescribeEventCategories")
  .asString();
const 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=DescribeEventCategories');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DescribeEventCategories',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeEventCategories';
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=DescribeEventCategories',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeEventCategories")
  .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=DescribeEventCategories',
  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=DescribeEventCategories');

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=DescribeEventCategories',
  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=DescribeEventCategories';
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=DescribeEventCategories"]
                                                       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=DescribeEventCategories" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeEventCategories",
  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=DescribeEventCategories');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeEventCategories');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeEventCategories');
$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=DescribeEventCategories' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeEventCategories' -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=DescribeEventCategories"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeEventCategories"

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=DescribeEventCategories")

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=DescribeEventCategories";

    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=DescribeEventCategories'
http POST '{{baseUrl}}/?Action=&Version=#Action=DescribeEventCategories'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeEventCategories'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeEventCategories")! 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_DescribeEventSubscriptions
{{baseUrl}}/#Action=DescribeEventSubscriptions
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=DescribeEventSubscriptions");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DescribeEventSubscriptions" {:query-params {:Action ""
                                                                                              :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeEventSubscriptions"

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=DescribeEventSubscriptions"),
};
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=DescribeEventSubscriptions");
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=DescribeEventSubscriptions"

	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=DescribeEventSubscriptions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeEventSubscriptions"))
    .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=DescribeEventSubscriptions")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DescribeEventSubscriptions")
  .asString();
const 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=DescribeEventSubscriptions');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DescribeEventSubscriptions',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeEventSubscriptions';
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=DescribeEventSubscriptions',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeEventSubscriptions")
  .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=DescribeEventSubscriptions',
  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=DescribeEventSubscriptions');

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=DescribeEventSubscriptions',
  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=DescribeEventSubscriptions';
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=DescribeEventSubscriptions"]
                                                       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=DescribeEventSubscriptions" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeEventSubscriptions",
  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=DescribeEventSubscriptions');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeEventSubscriptions');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeEventSubscriptions');
$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=DescribeEventSubscriptions' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeEventSubscriptions' -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=DescribeEventSubscriptions"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeEventSubscriptions"

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=DescribeEventSubscriptions")

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=DescribeEventSubscriptions";

    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=DescribeEventSubscriptions'
http POST '{{baseUrl}}/?Action=&Version=#Action=DescribeEventSubscriptions'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeEventSubscriptions'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeEventSubscriptions")! 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_DescribeEvents
{{baseUrl}}/#Action=DescribeEvents
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=DescribeEvents");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DescribeEvents" {:query-params {:Action ""
                                                                                  :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeEvents"

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=DescribeEvents"),
};
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=DescribeEvents");
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=DescribeEvents"

	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=DescribeEvents")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeEvents"))
    .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=DescribeEvents")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DescribeEvents")
  .asString();
const 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=DescribeEvents');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DescribeEvents',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeEvents';
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=DescribeEvents',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeEvents")
  .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=DescribeEvents',
  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=DescribeEvents');

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=DescribeEvents',
  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=DescribeEvents';
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=DescribeEvents"]
                                                       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=DescribeEvents" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeEvents",
  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=DescribeEvents');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeEvents');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeEvents');
$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=DescribeEvents' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeEvents' -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=DescribeEvents"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeEvents"

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=DescribeEvents")

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=DescribeEvents";

    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=DescribeEvents'
http POST '{{baseUrl}}/?Action=&Version=#Action=DescribeEvents'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeEvents'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeEvents")! 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_DescribeGlobalClusters
{{baseUrl}}/#Action=DescribeGlobalClusters
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=DescribeGlobalClusters");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DescribeGlobalClusters" {:query-params {:Action ""
                                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeGlobalClusters"

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=DescribeGlobalClusters"),
};
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=DescribeGlobalClusters");
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=DescribeGlobalClusters"

	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=DescribeGlobalClusters")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeGlobalClusters"))
    .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=DescribeGlobalClusters")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DescribeGlobalClusters")
  .asString();
const 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=DescribeGlobalClusters');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DescribeGlobalClusters',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeGlobalClusters';
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=DescribeGlobalClusters',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeGlobalClusters")
  .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=DescribeGlobalClusters',
  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=DescribeGlobalClusters');

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=DescribeGlobalClusters',
  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=DescribeGlobalClusters';
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=DescribeGlobalClusters"]
                                                       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=DescribeGlobalClusters" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeGlobalClusters",
  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=DescribeGlobalClusters');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeGlobalClusters');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeGlobalClusters');
$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=DescribeGlobalClusters' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeGlobalClusters' -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=DescribeGlobalClusters"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeGlobalClusters"

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=DescribeGlobalClusters")

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=DescribeGlobalClusters";

    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=DescribeGlobalClusters'
http POST '{{baseUrl}}/?Action=&Version=#Action=DescribeGlobalClusters'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeGlobalClusters'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeGlobalClusters")! 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_DescribeOrderableDBInstanceOptions
{{baseUrl}}/#Action=DescribeOrderableDBInstanceOptions
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=DescribeOrderableDBInstanceOptions");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DescribeOrderableDBInstanceOptions" {:query-params {:Action ""
                                                                                                      :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeOrderableDBInstanceOptions"

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=DescribeOrderableDBInstanceOptions"),
};
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=DescribeOrderableDBInstanceOptions");
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=DescribeOrderableDBInstanceOptions"

	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=DescribeOrderableDBInstanceOptions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeOrderableDBInstanceOptions"))
    .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=DescribeOrderableDBInstanceOptions")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DescribeOrderableDBInstanceOptions")
  .asString();
const 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=DescribeOrderableDBInstanceOptions');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DescribeOrderableDBInstanceOptions',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeOrderableDBInstanceOptions';
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=DescribeOrderableDBInstanceOptions',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeOrderableDBInstanceOptions")
  .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=DescribeOrderableDBInstanceOptions',
  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=DescribeOrderableDBInstanceOptions');

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=DescribeOrderableDBInstanceOptions',
  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=DescribeOrderableDBInstanceOptions';
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=DescribeOrderableDBInstanceOptions"]
                                                       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=DescribeOrderableDBInstanceOptions" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeOrderableDBInstanceOptions",
  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=DescribeOrderableDBInstanceOptions');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeOrderableDBInstanceOptions');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeOrderableDBInstanceOptions');
$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=DescribeOrderableDBInstanceOptions' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeOrderableDBInstanceOptions' -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=DescribeOrderableDBInstanceOptions"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeOrderableDBInstanceOptions"

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=DescribeOrderableDBInstanceOptions")

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=DescribeOrderableDBInstanceOptions";

    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=DescribeOrderableDBInstanceOptions'
http POST '{{baseUrl}}/?Action=&Version=#Action=DescribeOrderableDBInstanceOptions'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeOrderableDBInstanceOptions'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeOrderableDBInstanceOptions")! 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_DescribePendingMaintenanceActions
{{baseUrl}}/#Action=DescribePendingMaintenanceActions
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=DescribePendingMaintenanceActions");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DescribePendingMaintenanceActions" {:query-params {:Action ""
                                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribePendingMaintenanceActions"

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=DescribePendingMaintenanceActions"),
};
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=DescribePendingMaintenanceActions");
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=DescribePendingMaintenanceActions"

	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=DescribePendingMaintenanceActions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribePendingMaintenanceActions"))
    .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=DescribePendingMaintenanceActions")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DescribePendingMaintenanceActions")
  .asString();
const 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=DescribePendingMaintenanceActions');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DescribePendingMaintenanceActions',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribePendingMaintenanceActions';
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=DescribePendingMaintenanceActions',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribePendingMaintenanceActions")
  .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=DescribePendingMaintenanceActions',
  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=DescribePendingMaintenanceActions');

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=DescribePendingMaintenanceActions',
  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=DescribePendingMaintenanceActions';
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=DescribePendingMaintenanceActions"]
                                                       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=DescribePendingMaintenanceActions" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribePendingMaintenanceActions",
  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=DescribePendingMaintenanceActions');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribePendingMaintenanceActions');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribePendingMaintenanceActions');
$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=DescribePendingMaintenanceActions' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribePendingMaintenanceActions' -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=DescribePendingMaintenanceActions"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribePendingMaintenanceActions"

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=DescribePendingMaintenanceActions")

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=DescribePendingMaintenanceActions";

    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=DescribePendingMaintenanceActions'
http POST '{{baseUrl}}/?Action=&Version=#Action=DescribePendingMaintenanceActions'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribePendingMaintenanceActions'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribePendingMaintenanceActions")! 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_DescribeValidDBInstanceModifications
{{baseUrl}}/#Action=DescribeValidDBInstanceModifications
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=DescribeValidDBInstanceModifications");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=DescribeValidDBInstanceModifications" {:query-params {:Action ""
                                                                                                        :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=DescribeValidDBInstanceModifications"

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=DescribeValidDBInstanceModifications"),
};
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=DescribeValidDBInstanceModifications");
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=DescribeValidDBInstanceModifications"

	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=DescribeValidDBInstanceModifications")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=DescribeValidDBInstanceModifications"))
    .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=DescribeValidDBInstanceModifications")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=DescribeValidDBInstanceModifications")
  .asString();
const 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=DescribeValidDBInstanceModifications');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=DescribeValidDBInstanceModifications',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=DescribeValidDBInstanceModifications';
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=DescribeValidDBInstanceModifications',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=DescribeValidDBInstanceModifications")
  .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=DescribeValidDBInstanceModifications',
  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=DescribeValidDBInstanceModifications');

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=DescribeValidDBInstanceModifications',
  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=DescribeValidDBInstanceModifications';
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=DescribeValidDBInstanceModifications"]
                                                       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=DescribeValidDBInstanceModifications" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=DescribeValidDBInstanceModifications",
  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=DescribeValidDBInstanceModifications');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=DescribeValidDBInstanceModifications');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=DescribeValidDBInstanceModifications');
$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=DescribeValidDBInstanceModifications' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=DescribeValidDBInstanceModifications' -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=DescribeValidDBInstanceModifications"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=DescribeValidDBInstanceModifications"

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=DescribeValidDBInstanceModifications")

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=DescribeValidDBInstanceModifications";

    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=DescribeValidDBInstanceModifications'
http POST '{{baseUrl}}/?Action=&Version=#Action=DescribeValidDBInstanceModifications'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=DescribeValidDBInstanceModifications'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=DescribeValidDBInstanceModifications")! 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_FailoverDBCluster
{{baseUrl}}/#Action=FailoverDBCluster
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=FailoverDBCluster");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=FailoverDBCluster" {:query-params {:Action ""
                                                                                     :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=FailoverDBCluster"

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=FailoverDBCluster"),
};
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=FailoverDBCluster");
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=FailoverDBCluster"

	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=FailoverDBCluster")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=FailoverDBCluster"))
    .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=FailoverDBCluster")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=FailoverDBCluster")
  .asString();
const 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=FailoverDBCluster');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=FailoverDBCluster',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=FailoverDBCluster';
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=FailoverDBCluster',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=FailoverDBCluster")
  .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=FailoverDBCluster',
  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=FailoverDBCluster');

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=FailoverDBCluster',
  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=FailoverDBCluster';
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=FailoverDBCluster"]
                                                       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=FailoverDBCluster" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=FailoverDBCluster",
  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=FailoverDBCluster');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=FailoverDBCluster');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=FailoverDBCluster');
$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=FailoverDBCluster' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=FailoverDBCluster' -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=FailoverDBCluster"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=FailoverDBCluster"

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=FailoverDBCluster")

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=FailoverDBCluster";

    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=FailoverDBCluster'
http POST '{{baseUrl}}/?Action=&Version=#Action=FailoverDBCluster'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=FailoverDBCluster'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=FailoverDBCluster")! 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_FailoverGlobalCluster
{{baseUrl}}/#Action=FailoverGlobalCluster
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=FailoverGlobalCluster");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=FailoverGlobalCluster" {:query-params {:Action ""
                                                                                         :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=FailoverGlobalCluster"

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=FailoverGlobalCluster"),
};
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=FailoverGlobalCluster");
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=FailoverGlobalCluster"

	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=FailoverGlobalCluster")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=FailoverGlobalCluster"))
    .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=FailoverGlobalCluster")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=FailoverGlobalCluster")
  .asString();
const 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=FailoverGlobalCluster');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=FailoverGlobalCluster',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=FailoverGlobalCluster';
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=FailoverGlobalCluster',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=FailoverGlobalCluster")
  .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=FailoverGlobalCluster',
  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=FailoverGlobalCluster');

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=FailoverGlobalCluster',
  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=FailoverGlobalCluster';
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=FailoverGlobalCluster"]
                                                       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=FailoverGlobalCluster" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=FailoverGlobalCluster",
  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=FailoverGlobalCluster');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=FailoverGlobalCluster');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=FailoverGlobalCluster');
$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=FailoverGlobalCluster' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=FailoverGlobalCluster' -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=FailoverGlobalCluster"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=FailoverGlobalCluster"

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=FailoverGlobalCluster")

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=FailoverGlobalCluster";

    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=FailoverGlobalCluster'
http POST '{{baseUrl}}/?Action=&Version=#Action=FailoverGlobalCluster'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=FailoverGlobalCluster'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=FailoverGlobalCluster")! 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_ListTagsForResource
{{baseUrl}}/#Action=ListTagsForResource
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=ListTagsForResource");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ListTagsForResource" {:query-params {:Action ""
                                                                                       :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ListTagsForResource"

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=ListTagsForResource"),
};
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=ListTagsForResource");
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=ListTagsForResource"

	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=ListTagsForResource")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ListTagsForResource"))
    .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=ListTagsForResource")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ListTagsForResource")
  .asString();
const 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=ListTagsForResource');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ListTagsForResource',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ListTagsForResource';
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=ListTagsForResource',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ListTagsForResource")
  .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=ListTagsForResource',
  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=ListTagsForResource');

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=ListTagsForResource',
  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=ListTagsForResource';
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=ListTagsForResource"]
                                                       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=ListTagsForResource" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ListTagsForResource",
  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=ListTagsForResource');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ListTagsForResource');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ListTagsForResource');
$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=ListTagsForResource' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ListTagsForResource' -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=ListTagsForResource"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ListTagsForResource"

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=ListTagsForResource")

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=ListTagsForResource";

    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=ListTagsForResource'
http POST '{{baseUrl}}/?Action=&Version=#Action=ListTagsForResource'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ListTagsForResource'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ListTagsForResource")! 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_ModifyDBCluster
{{baseUrl}}/#Action=ModifyDBCluster
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=ModifyDBCluster");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ModifyDBCluster" {:query-params {:Action ""
                                                                                   :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ModifyDBCluster"

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=ModifyDBCluster"),
};
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=ModifyDBCluster");
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=ModifyDBCluster"

	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=ModifyDBCluster")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ModifyDBCluster"))
    .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=ModifyDBCluster")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ModifyDBCluster")
  .asString();
const 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=ModifyDBCluster');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ModifyDBCluster',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ModifyDBCluster';
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=ModifyDBCluster',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ModifyDBCluster")
  .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=ModifyDBCluster',
  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=ModifyDBCluster');

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=ModifyDBCluster',
  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=ModifyDBCluster';
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=ModifyDBCluster"]
                                                       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=ModifyDBCluster" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ModifyDBCluster",
  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=ModifyDBCluster');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ModifyDBCluster');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ModifyDBCluster');
$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=ModifyDBCluster' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ModifyDBCluster' -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=ModifyDBCluster"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ModifyDBCluster"

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=ModifyDBCluster")

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=ModifyDBCluster";

    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=ModifyDBCluster'
http POST '{{baseUrl}}/?Action=&Version=#Action=ModifyDBCluster'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ModifyDBCluster'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ModifyDBCluster")! 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_ModifyDBClusterEndpoint
{{baseUrl}}/#Action=ModifyDBClusterEndpoint
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=ModifyDBClusterEndpoint");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ModifyDBClusterEndpoint" {:query-params {:Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterEndpoint"

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=ModifyDBClusterEndpoint"),
};
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=ModifyDBClusterEndpoint");
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=ModifyDBClusterEndpoint"

	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=ModifyDBClusterEndpoint")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterEndpoint"))
    .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=ModifyDBClusterEndpoint")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterEndpoint")
  .asString();
const 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=ModifyDBClusterEndpoint');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ModifyDBClusterEndpoint',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterEndpoint';
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=ModifyDBClusterEndpoint',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterEndpoint")
  .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=ModifyDBClusterEndpoint',
  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=ModifyDBClusterEndpoint');

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=ModifyDBClusterEndpoint',
  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=ModifyDBClusterEndpoint';
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=ModifyDBClusterEndpoint"]
                                                       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=ModifyDBClusterEndpoint" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterEndpoint",
  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=ModifyDBClusterEndpoint');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ModifyDBClusterEndpoint');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ModifyDBClusterEndpoint');
$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=ModifyDBClusterEndpoint' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterEndpoint' -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=ModifyDBClusterEndpoint"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ModifyDBClusterEndpoint"

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=ModifyDBClusterEndpoint")

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=ModifyDBClusterEndpoint";

    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=ModifyDBClusterEndpoint'
http POST '{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterEndpoint'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterEndpoint'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterEndpoint")! 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_ModifyDBClusterParameterGroup
{{baseUrl}}/#Action=ModifyDBClusterParameterGroup
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=ModifyDBClusterParameterGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ModifyDBClusterParameterGroup" {:query-params {:Action ""
                                                                                                 :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterParameterGroup"

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=ModifyDBClusterParameterGroup"),
};
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=ModifyDBClusterParameterGroup");
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=ModifyDBClusterParameterGroup"

	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=ModifyDBClusterParameterGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterParameterGroup"))
    .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=ModifyDBClusterParameterGroup")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterParameterGroup")
  .asString();
const 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=ModifyDBClusterParameterGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ModifyDBClusterParameterGroup',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterParameterGroup';
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=ModifyDBClusterParameterGroup',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterParameterGroup")
  .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=ModifyDBClusterParameterGroup',
  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=ModifyDBClusterParameterGroup');

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=ModifyDBClusterParameterGroup',
  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=ModifyDBClusterParameterGroup';
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=ModifyDBClusterParameterGroup"]
                                                       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=ModifyDBClusterParameterGroup" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterParameterGroup",
  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=ModifyDBClusterParameterGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ModifyDBClusterParameterGroup');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ModifyDBClusterParameterGroup');
$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=ModifyDBClusterParameterGroup' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterParameterGroup' -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=ModifyDBClusterParameterGroup"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ModifyDBClusterParameterGroup"

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=ModifyDBClusterParameterGroup")

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=ModifyDBClusterParameterGroup";

    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=ModifyDBClusterParameterGroup'
http POST '{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterParameterGroup'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterParameterGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterParameterGroup")! 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_ModifyDBClusterSnapshotAttribute
{{baseUrl}}/#Action=ModifyDBClusterSnapshotAttribute
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=ModifyDBClusterSnapshotAttribute");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ModifyDBClusterSnapshotAttribute" {:query-params {:Action ""
                                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterSnapshotAttribute"

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=ModifyDBClusterSnapshotAttribute"),
};
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=ModifyDBClusterSnapshotAttribute");
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=ModifyDBClusterSnapshotAttribute"

	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=ModifyDBClusterSnapshotAttribute")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterSnapshotAttribute"))
    .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=ModifyDBClusterSnapshotAttribute")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterSnapshotAttribute")
  .asString();
const 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=ModifyDBClusterSnapshotAttribute');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ModifyDBClusterSnapshotAttribute',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterSnapshotAttribute';
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=ModifyDBClusterSnapshotAttribute',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterSnapshotAttribute")
  .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=ModifyDBClusterSnapshotAttribute',
  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=ModifyDBClusterSnapshotAttribute');

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=ModifyDBClusterSnapshotAttribute',
  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=ModifyDBClusterSnapshotAttribute';
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=ModifyDBClusterSnapshotAttribute"]
                                                       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=ModifyDBClusterSnapshotAttribute" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterSnapshotAttribute",
  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=ModifyDBClusterSnapshotAttribute');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ModifyDBClusterSnapshotAttribute');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ModifyDBClusterSnapshotAttribute');
$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=ModifyDBClusterSnapshotAttribute' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterSnapshotAttribute' -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=ModifyDBClusterSnapshotAttribute"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ModifyDBClusterSnapshotAttribute"

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=ModifyDBClusterSnapshotAttribute")

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=ModifyDBClusterSnapshotAttribute";

    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=ModifyDBClusterSnapshotAttribute'
http POST '{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterSnapshotAttribute'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterSnapshotAttribute'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ModifyDBClusterSnapshotAttribute")! 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_ModifyDBInstance
{{baseUrl}}/#Action=ModifyDBInstance
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=ModifyDBInstance");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ModifyDBInstance" {:query-params {:Action ""
                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ModifyDBInstance"

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=ModifyDBInstance"),
};
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=ModifyDBInstance");
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=ModifyDBInstance"

	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=ModifyDBInstance")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ModifyDBInstance"))
    .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=ModifyDBInstance")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ModifyDBInstance")
  .asString();
const 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=ModifyDBInstance');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ModifyDBInstance',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ModifyDBInstance';
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=ModifyDBInstance',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ModifyDBInstance")
  .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=ModifyDBInstance',
  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=ModifyDBInstance');

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=ModifyDBInstance',
  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=ModifyDBInstance';
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=ModifyDBInstance"]
                                                       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=ModifyDBInstance" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ModifyDBInstance",
  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=ModifyDBInstance');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ModifyDBInstance');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ModifyDBInstance');
$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=ModifyDBInstance' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ModifyDBInstance' -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=ModifyDBInstance"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ModifyDBInstance"

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=ModifyDBInstance")

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=ModifyDBInstance";

    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=ModifyDBInstance'
http POST '{{baseUrl}}/?Action=&Version=#Action=ModifyDBInstance'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ModifyDBInstance'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ModifyDBInstance")! 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_ModifyDBParameterGroup
{{baseUrl}}/#Action=ModifyDBParameterGroup
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=ModifyDBParameterGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ModifyDBParameterGroup" {:query-params {:Action ""
                                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ModifyDBParameterGroup"

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=ModifyDBParameterGroup"),
};
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=ModifyDBParameterGroup");
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=ModifyDBParameterGroup"

	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=ModifyDBParameterGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ModifyDBParameterGroup"))
    .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=ModifyDBParameterGroup")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ModifyDBParameterGroup")
  .asString();
const 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=ModifyDBParameterGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ModifyDBParameterGroup',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ModifyDBParameterGroup';
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=ModifyDBParameterGroup',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ModifyDBParameterGroup")
  .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=ModifyDBParameterGroup',
  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=ModifyDBParameterGroup');

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=ModifyDBParameterGroup',
  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=ModifyDBParameterGroup';
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=ModifyDBParameterGroup"]
                                                       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=ModifyDBParameterGroup" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ModifyDBParameterGroup",
  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=ModifyDBParameterGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ModifyDBParameterGroup');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ModifyDBParameterGroup');
$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=ModifyDBParameterGroup' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ModifyDBParameterGroup' -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=ModifyDBParameterGroup"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ModifyDBParameterGroup"

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=ModifyDBParameterGroup")

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=ModifyDBParameterGroup";

    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=ModifyDBParameterGroup'
http POST '{{baseUrl}}/?Action=&Version=#Action=ModifyDBParameterGroup'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ModifyDBParameterGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ModifyDBParameterGroup")! 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_ModifyDBSubnetGroup
{{baseUrl}}/#Action=ModifyDBSubnetGroup
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=ModifyDBSubnetGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ModifyDBSubnetGroup" {:query-params {:Action ""
                                                                                       :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ModifyDBSubnetGroup"

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=ModifyDBSubnetGroup"),
};
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=ModifyDBSubnetGroup");
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=ModifyDBSubnetGroup"

	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=ModifyDBSubnetGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ModifyDBSubnetGroup"))
    .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=ModifyDBSubnetGroup")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ModifyDBSubnetGroup")
  .asString();
const 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=ModifyDBSubnetGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ModifyDBSubnetGroup',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ModifyDBSubnetGroup';
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=ModifyDBSubnetGroup',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ModifyDBSubnetGroup")
  .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=ModifyDBSubnetGroup',
  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=ModifyDBSubnetGroup');

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=ModifyDBSubnetGroup',
  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=ModifyDBSubnetGroup';
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=ModifyDBSubnetGroup"]
                                                       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=ModifyDBSubnetGroup" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ModifyDBSubnetGroup",
  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=ModifyDBSubnetGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ModifyDBSubnetGroup');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ModifyDBSubnetGroup');
$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=ModifyDBSubnetGroup' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ModifyDBSubnetGroup' -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=ModifyDBSubnetGroup"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ModifyDBSubnetGroup"

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=ModifyDBSubnetGroup")

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=ModifyDBSubnetGroup";

    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=ModifyDBSubnetGroup'
http POST '{{baseUrl}}/?Action=&Version=#Action=ModifyDBSubnetGroup'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ModifyDBSubnetGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ModifyDBSubnetGroup")! 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_ModifyEventSubscription
{{baseUrl}}/#Action=ModifyEventSubscription
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=ModifyEventSubscription");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ModifyEventSubscription" {:query-params {:Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ModifyEventSubscription"

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=ModifyEventSubscription"),
};
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=ModifyEventSubscription");
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=ModifyEventSubscription"

	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=ModifyEventSubscription")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ModifyEventSubscription"))
    .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=ModifyEventSubscription")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ModifyEventSubscription")
  .asString();
const 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=ModifyEventSubscription');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ModifyEventSubscription',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ModifyEventSubscription';
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=ModifyEventSubscription',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ModifyEventSubscription")
  .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=ModifyEventSubscription',
  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=ModifyEventSubscription');

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=ModifyEventSubscription',
  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=ModifyEventSubscription';
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=ModifyEventSubscription"]
                                                       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=ModifyEventSubscription" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ModifyEventSubscription",
  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=ModifyEventSubscription');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ModifyEventSubscription');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ModifyEventSubscription');
$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=ModifyEventSubscription' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ModifyEventSubscription' -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=ModifyEventSubscription"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ModifyEventSubscription"

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=ModifyEventSubscription")

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=ModifyEventSubscription";

    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=ModifyEventSubscription'
http POST '{{baseUrl}}/?Action=&Version=#Action=ModifyEventSubscription'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ModifyEventSubscription'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ModifyEventSubscription")! 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_ModifyGlobalCluster
{{baseUrl}}/#Action=ModifyGlobalCluster
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=ModifyGlobalCluster");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ModifyGlobalCluster" {:query-params {:Action ""
                                                                                       :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ModifyGlobalCluster"

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=ModifyGlobalCluster"),
};
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=ModifyGlobalCluster");
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=ModifyGlobalCluster"

	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=ModifyGlobalCluster")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ModifyGlobalCluster"))
    .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=ModifyGlobalCluster")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ModifyGlobalCluster")
  .asString();
const 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=ModifyGlobalCluster');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ModifyGlobalCluster',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ModifyGlobalCluster';
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=ModifyGlobalCluster',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ModifyGlobalCluster")
  .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=ModifyGlobalCluster',
  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=ModifyGlobalCluster');

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=ModifyGlobalCluster',
  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=ModifyGlobalCluster';
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=ModifyGlobalCluster"]
                                                       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=ModifyGlobalCluster" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ModifyGlobalCluster",
  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=ModifyGlobalCluster');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ModifyGlobalCluster');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ModifyGlobalCluster');
$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=ModifyGlobalCluster' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ModifyGlobalCluster' -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=ModifyGlobalCluster"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ModifyGlobalCluster"

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=ModifyGlobalCluster")

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=ModifyGlobalCluster";

    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=ModifyGlobalCluster'
http POST '{{baseUrl}}/?Action=&Version=#Action=ModifyGlobalCluster'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ModifyGlobalCluster'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ModifyGlobalCluster")! 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_PromoteReadReplicaDBCluster
{{baseUrl}}/#Action=PromoteReadReplicaDBCluster
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=PromoteReadReplicaDBCluster");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=PromoteReadReplicaDBCluster" {:query-params {:Action ""
                                                                                               :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=PromoteReadReplicaDBCluster"

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=PromoteReadReplicaDBCluster"),
};
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=PromoteReadReplicaDBCluster");
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=PromoteReadReplicaDBCluster"

	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=PromoteReadReplicaDBCluster")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=PromoteReadReplicaDBCluster"))
    .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=PromoteReadReplicaDBCluster")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=PromoteReadReplicaDBCluster")
  .asString();
const 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=PromoteReadReplicaDBCluster');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=PromoteReadReplicaDBCluster',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=PromoteReadReplicaDBCluster';
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=PromoteReadReplicaDBCluster',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=PromoteReadReplicaDBCluster")
  .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=PromoteReadReplicaDBCluster',
  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=PromoteReadReplicaDBCluster');

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=PromoteReadReplicaDBCluster',
  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=PromoteReadReplicaDBCluster';
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=PromoteReadReplicaDBCluster"]
                                                       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=PromoteReadReplicaDBCluster" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=PromoteReadReplicaDBCluster",
  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=PromoteReadReplicaDBCluster');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=PromoteReadReplicaDBCluster');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=PromoteReadReplicaDBCluster');
$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=PromoteReadReplicaDBCluster' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=PromoteReadReplicaDBCluster' -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=PromoteReadReplicaDBCluster"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=PromoteReadReplicaDBCluster"

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=PromoteReadReplicaDBCluster")

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=PromoteReadReplicaDBCluster";

    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=PromoteReadReplicaDBCluster'
http POST '{{baseUrl}}/?Action=&Version=#Action=PromoteReadReplicaDBCluster'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=PromoteReadReplicaDBCluster'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=PromoteReadReplicaDBCluster")! 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_RebootDBInstance
{{baseUrl}}/#Action=RebootDBInstance
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=RebootDBInstance");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=RebootDBInstance" {:query-params {:Action ""
                                                                                    :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=RebootDBInstance"

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=RebootDBInstance"),
};
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=RebootDBInstance");
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=RebootDBInstance"

	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=RebootDBInstance")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=RebootDBInstance"))
    .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=RebootDBInstance")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=RebootDBInstance")
  .asString();
const 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=RebootDBInstance');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=RebootDBInstance',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=RebootDBInstance';
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=RebootDBInstance',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=RebootDBInstance")
  .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=RebootDBInstance',
  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=RebootDBInstance');

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=RebootDBInstance',
  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=RebootDBInstance';
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=RebootDBInstance"]
                                                       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=RebootDBInstance" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=RebootDBInstance",
  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=RebootDBInstance');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=RebootDBInstance');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=RebootDBInstance');
$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=RebootDBInstance' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=RebootDBInstance' -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=RebootDBInstance"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=RebootDBInstance"

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=RebootDBInstance")

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=RebootDBInstance";

    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=RebootDBInstance'
http POST '{{baseUrl}}/?Action=&Version=#Action=RebootDBInstance'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=RebootDBInstance'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=RebootDBInstance")! 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_RemoveFromGlobalCluster
{{baseUrl}}/#Action=RemoveFromGlobalCluster
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=RemoveFromGlobalCluster");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=RemoveFromGlobalCluster" {:query-params {:Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=RemoveFromGlobalCluster"

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=RemoveFromGlobalCluster"),
};
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=RemoveFromGlobalCluster");
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=RemoveFromGlobalCluster"

	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=RemoveFromGlobalCluster")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=RemoveFromGlobalCluster"))
    .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=RemoveFromGlobalCluster")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=RemoveFromGlobalCluster")
  .asString();
const 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=RemoveFromGlobalCluster');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=RemoveFromGlobalCluster',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=RemoveFromGlobalCluster';
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=RemoveFromGlobalCluster',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=RemoveFromGlobalCluster")
  .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=RemoveFromGlobalCluster',
  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=RemoveFromGlobalCluster');

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=RemoveFromGlobalCluster',
  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=RemoveFromGlobalCluster';
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=RemoveFromGlobalCluster"]
                                                       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=RemoveFromGlobalCluster" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=RemoveFromGlobalCluster",
  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=RemoveFromGlobalCluster');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=RemoveFromGlobalCluster');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=RemoveFromGlobalCluster');
$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=RemoveFromGlobalCluster' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=RemoveFromGlobalCluster' -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=RemoveFromGlobalCluster"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=RemoveFromGlobalCluster"

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=RemoveFromGlobalCluster")

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=RemoveFromGlobalCluster";

    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=RemoveFromGlobalCluster'
http POST '{{baseUrl}}/?Action=&Version=#Action=RemoveFromGlobalCluster'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=RemoveFromGlobalCluster'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=RemoveFromGlobalCluster")! 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_RemoveRoleFromDBCluster
{{baseUrl}}/#Action=RemoveRoleFromDBCluster
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=RemoveRoleFromDBCluster");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=RemoveRoleFromDBCluster" {:query-params {:Action ""
                                                                                           :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=RemoveRoleFromDBCluster"

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=RemoveRoleFromDBCluster"),
};
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=RemoveRoleFromDBCluster");
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=RemoveRoleFromDBCluster"

	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=RemoveRoleFromDBCluster")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=RemoveRoleFromDBCluster"))
    .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=RemoveRoleFromDBCluster")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=RemoveRoleFromDBCluster")
  .asString();
const 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=RemoveRoleFromDBCluster');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=RemoveRoleFromDBCluster',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=RemoveRoleFromDBCluster';
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=RemoveRoleFromDBCluster',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=RemoveRoleFromDBCluster")
  .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=RemoveRoleFromDBCluster',
  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=RemoveRoleFromDBCluster');

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=RemoveRoleFromDBCluster',
  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=RemoveRoleFromDBCluster';
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=RemoveRoleFromDBCluster"]
                                                       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=RemoveRoleFromDBCluster" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=RemoveRoleFromDBCluster",
  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=RemoveRoleFromDBCluster');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=RemoveRoleFromDBCluster');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=RemoveRoleFromDBCluster');
$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=RemoveRoleFromDBCluster' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=RemoveRoleFromDBCluster' -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=RemoveRoleFromDBCluster"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=RemoveRoleFromDBCluster"

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=RemoveRoleFromDBCluster")

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=RemoveRoleFromDBCluster";

    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=RemoveRoleFromDBCluster'
http POST '{{baseUrl}}/?Action=&Version=#Action=RemoveRoleFromDBCluster'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=RemoveRoleFromDBCluster'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=RemoveRoleFromDBCluster")! 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_RemoveSourceIdentifierFromSubscription
{{baseUrl}}/#Action=RemoveSourceIdentifierFromSubscription
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=RemoveSourceIdentifierFromSubscription");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=RemoveSourceIdentifierFromSubscription" {:query-params {:Action ""
                                                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=RemoveSourceIdentifierFromSubscription"

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=RemoveSourceIdentifierFromSubscription"),
};
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=RemoveSourceIdentifierFromSubscription");
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=RemoveSourceIdentifierFromSubscription"

	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=RemoveSourceIdentifierFromSubscription")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=RemoveSourceIdentifierFromSubscription"))
    .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=RemoveSourceIdentifierFromSubscription")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=RemoveSourceIdentifierFromSubscription")
  .asString();
const 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=RemoveSourceIdentifierFromSubscription');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=RemoveSourceIdentifierFromSubscription',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=RemoveSourceIdentifierFromSubscription';
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=RemoveSourceIdentifierFromSubscription',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=RemoveSourceIdentifierFromSubscription")
  .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=RemoveSourceIdentifierFromSubscription',
  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=RemoveSourceIdentifierFromSubscription');

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=RemoveSourceIdentifierFromSubscription',
  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=RemoveSourceIdentifierFromSubscription';
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=RemoveSourceIdentifierFromSubscription"]
                                                       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=RemoveSourceIdentifierFromSubscription" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=RemoveSourceIdentifierFromSubscription",
  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=RemoveSourceIdentifierFromSubscription');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=RemoveSourceIdentifierFromSubscription');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=RemoveSourceIdentifierFromSubscription');
$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=RemoveSourceIdentifierFromSubscription' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=RemoveSourceIdentifierFromSubscription' -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=RemoveSourceIdentifierFromSubscription"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=RemoveSourceIdentifierFromSubscription"

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=RemoveSourceIdentifierFromSubscription")

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=RemoveSourceIdentifierFromSubscription";

    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=RemoveSourceIdentifierFromSubscription'
http POST '{{baseUrl}}/?Action=&Version=#Action=RemoveSourceIdentifierFromSubscription'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=RemoveSourceIdentifierFromSubscription'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=RemoveSourceIdentifierFromSubscription")! 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_RemoveTagsFromResource
{{baseUrl}}/#Action=RemoveTagsFromResource
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=RemoveTagsFromResource");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=RemoveTagsFromResource" {:query-params {:Action ""
                                                                                          :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=RemoveTagsFromResource"

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=RemoveTagsFromResource"),
};
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=RemoveTagsFromResource");
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=RemoveTagsFromResource"

	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=RemoveTagsFromResource")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=RemoveTagsFromResource"))
    .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=RemoveTagsFromResource")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=RemoveTagsFromResource")
  .asString();
const 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=RemoveTagsFromResource');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=RemoveTagsFromResource',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=RemoveTagsFromResource';
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=RemoveTagsFromResource',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=RemoveTagsFromResource")
  .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=RemoveTagsFromResource',
  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=RemoveTagsFromResource');

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=RemoveTagsFromResource',
  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=RemoveTagsFromResource';
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=RemoveTagsFromResource"]
                                                       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=RemoveTagsFromResource" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=RemoveTagsFromResource",
  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=RemoveTagsFromResource');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=RemoveTagsFromResource');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=RemoveTagsFromResource');
$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=RemoveTagsFromResource' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=RemoveTagsFromResource' -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=RemoveTagsFromResource"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=RemoveTagsFromResource"

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=RemoveTagsFromResource")

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=RemoveTagsFromResource";

    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=RemoveTagsFromResource'
http POST '{{baseUrl}}/?Action=&Version=#Action=RemoveTagsFromResource'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=RemoveTagsFromResource'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=RemoveTagsFromResource")! 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_ResetDBClusterParameterGroup
{{baseUrl}}/#Action=ResetDBClusterParameterGroup
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=ResetDBClusterParameterGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ResetDBClusterParameterGroup" {:query-params {:Action ""
                                                                                                :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ResetDBClusterParameterGroup"

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=ResetDBClusterParameterGroup"),
};
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=ResetDBClusterParameterGroup");
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=ResetDBClusterParameterGroup"

	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=ResetDBClusterParameterGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ResetDBClusterParameterGroup"))
    .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=ResetDBClusterParameterGroup")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ResetDBClusterParameterGroup")
  .asString();
const 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=ResetDBClusterParameterGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ResetDBClusterParameterGroup',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ResetDBClusterParameterGroup';
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=ResetDBClusterParameterGroup',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ResetDBClusterParameterGroup")
  .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=ResetDBClusterParameterGroup',
  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=ResetDBClusterParameterGroup');

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=ResetDBClusterParameterGroup',
  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=ResetDBClusterParameterGroup';
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=ResetDBClusterParameterGroup"]
                                                       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=ResetDBClusterParameterGroup" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ResetDBClusterParameterGroup",
  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=ResetDBClusterParameterGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ResetDBClusterParameterGroup');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ResetDBClusterParameterGroup');
$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=ResetDBClusterParameterGroup' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ResetDBClusterParameterGroup' -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=ResetDBClusterParameterGroup"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ResetDBClusterParameterGroup"

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=ResetDBClusterParameterGroup")

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=ResetDBClusterParameterGroup";

    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=ResetDBClusterParameterGroup'
http POST '{{baseUrl}}/?Action=&Version=#Action=ResetDBClusterParameterGroup'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ResetDBClusterParameterGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ResetDBClusterParameterGroup")! 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_ResetDBParameterGroup
{{baseUrl}}/#Action=ResetDBParameterGroup
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=ResetDBParameterGroup");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=ResetDBParameterGroup" {:query-params {:Action ""
                                                                                         :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=ResetDBParameterGroup"

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=ResetDBParameterGroup"),
};
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=ResetDBParameterGroup");
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=ResetDBParameterGroup"

	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=ResetDBParameterGroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=ResetDBParameterGroup"))
    .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=ResetDBParameterGroup")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=ResetDBParameterGroup")
  .asString();
const 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=ResetDBParameterGroup');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=ResetDBParameterGroup',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=ResetDBParameterGroup';
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=ResetDBParameterGroup',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=ResetDBParameterGroup")
  .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=ResetDBParameterGroup',
  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=ResetDBParameterGroup');

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=ResetDBParameterGroup',
  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=ResetDBParameterGroup';
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=ResetDBParameterGroup"]
                                                       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=ResetDBParameterGroup" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=ResetDBParameterGroup",
  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=ResetDBParameterGroup');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=ResetDBParameterGroup');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=ResetDBParameterGroup');
$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=ResetDBParameterGroup' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=ResetDBParameterGroup' -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=ResetDBParameterGroup"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=ResetDBParameterGroup"

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=ResetDBParameterGroup")

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=ResetDBParameterGroup";

    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=ResetDBParameterGroup'
http POST '{{baseUrl}}/?Action=&Version=#Action=ResetDBParameterGroup'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=ResetDBParameterGroup'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=ResetDBParameterGroup")! 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_RestoreDBClusterFromSnapshot
{{baseUrl}}/#Action=RestoreDBClusterFromSnapshot
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=RestoreDBClusterFromSnapshot");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=RestoreDBClusterFromSnapshot" {:query-params {:Action ""
                                                                                                :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=RestoreDBClusterFromSnapshot"

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=RestoreDBClusterFromSnapshot"),
};
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=RestoreDBClusterFromSnapshot");
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=RestoreDBClusterFromSnapshot"

	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=RestoreDBClusterFromSnapshot")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=RestoreDBClusterFromSnapshot"))
    .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=RestoreDBClusterFromSnapshot")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=RestoreDBClusterFromSnapshot")
  .asString();
const 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=RestoreDBClusterFromSnapshot');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=RestoreDBClusterFromSnapshot',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=RestoreDBClusterFromSnapshot';
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=RestoreDBClusterFromSnapshot',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=RestoreDBClusterFromSnapshot")
  .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=RestoreDBClusterFromSnapshot',
  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=RestoreDBClusterFromSnapshot');

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=RestoreDBClusterFromSnapshot',
  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=RestoreDBClusterFromSnapshot';
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=RestoreDBClusterFromSnapshot"]
                                                       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=RestoreDBClusterFromSnapshot" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=RestoreDBClusterFromSnapshot",
  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=RestoreDBClusterFromSnapshot');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=RestoreDBClusterFromSnapshot');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=RestoreDBClusterFromSnapshot');
$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=RestoreDBClusterFromSnapshot' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=RestoreDBClusterFromSnapshot' -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=RestoreDBClusterFromSnapshot"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=RestoreDBClusterFromSnapshot"

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=RestoreDBClusterFromSnapshot")

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=RestoreDBClusterFromSnapshot";

    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=RestoreDBClusterFromSnapshot'
http POST '{{baseUrl}}/?Action=&Version=#Action=RestoreDBClusterFromSnapshot'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=RestoreDBClusterFromSnapshot'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=RestoreDBClusterFromSnapshot")! 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_RestoreDBClusterToPointInTime
{{baseUrl}}/#Action=RestoreDBClusterToPointInTime
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=RestoreDBClusterToPointInTime");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=RestoreDBClusterToPointInTime" {:query-params {:Action ""
                                                                                                 :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=RestoreDBClusterToPointInTime"

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=RestoreDBClusterToPointInTime"),
};
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=RestoreDBClusterToPointInTime");
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=RestoreDBClusterToPointInTime"

	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=RestoreDBClusterToPointInTime")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=RestoreDBClusterToPointInTime"))
    .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=RestoreDBClusterToPointInTime")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=RestoreDBClusterToPointInTime")
  .asString();
const 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=RestoreDBClusterToPointInTime');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=RestoreDBClusterToPointInTime',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=RestoreDBClusterToPointInTime';
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=RestoreDBClusterToPointInTime',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=RestoreDBClusterToPointInTime")
  .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=RestoreDBClusterToPointInTime',
  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=RestoreDBClusterToPointInTime');

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=RestoreDBClusterToPointInTime',
  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=RestoreDBClusterToPointInTime';
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=RestoreDBClusterToPointInTime"]
                                                       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=RestoreDBClusterToPointInTime" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=RestoreDBClusterToPointInTime",
  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=RestoreDBClusterToPointInTime');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=RestoreDBClusterToPointInTime');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=RestoreDBClusterToPointInTime');
$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=RestoreDBClusterToPointInTime' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=RestoreDBClusterToPointInTime' -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=RestoreDBClusterToPointInTime"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=RestoreDBClusterToPointInTime"

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=RestoreDBClusterToPointInTime")

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=RestoreDBClusterToPointInTime";

    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=RestoreDBClusterToPointInTime'
http POST '{{baseUrl}}/?Action=&Version=#Action=RestoreDBClusterToPointInTime'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=RestoreDBClusterToPointInTime'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=RestoreDBClusterToPointInTime")! 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_StartDBCluster
{{baseUrl}}/#Action=StartDBCluster
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=StartDBCluster");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=StartDBCluster" {:query-params {:Action ""
                                                                                  :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=StartDBCluster"

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=StartDBCluster"),
};
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=StartDBCluster");
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=StartDBCluster"

	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=StartDBCluster")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=StartDBCluster"))
    .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=StartDBCluster")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=StartDBCluster")
  .asString();
const 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=StartDBCluster');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=StartDBCluster',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=StartDBCluster';
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=StartDBCluster',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=StartDBCluster")
  .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=StartDBCluster',
  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=StartDBCluster');

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=StartDBCluster',
  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=StartDBCluster';
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=StartDBCluster"]
                                                       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=StartDBCluster" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=StartDBCluster",
  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=StartDBCluster');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=StartDBCluster');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=StartDBCluster');
$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=StartDBCluster' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=StartDBCluster' -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=StartDBCluster"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=StartDBCluster"

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=StartDBCluster")

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=StartDBCluster";

    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=StartDBCluster'
http POST '{{baseUrl}}/?Action=&Version=#Action=StartDBCluster'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=StartDBCluster'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=StartDBCluster")! 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_StopDBCluster
{{baseUrl}}/#Action=StopDBCluster
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=StopDBCluster");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#Action=StopDBCluster" {:query-params {:Action ""
                                                                                 :Version ""}})
require "http/client"

url = "{{baseUrl}}/?Action=&Version=#Action=StopDBCluster"

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=StopDBCluster"),
};
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=StopDBCluster");
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=StopDBCluster"

	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=StopDBCluster")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/?Action=&Version=#Action=StopDBCluster"))
    .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=StopDBCluster")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/?Action=&Version=#Action=StopDBCluster")
  .asString();
const 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=StopDBCluster');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#Action=StopDBCluster',
  params: {Action: '', Version: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/?Action=&Version=#Action=StopDBCluster';
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=StopDBCluster',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/?Action=&Version=#Action=StopDBCluster")
  .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=StopDBCluster',
  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=StopDBCluster');

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=StopDBCluster',
  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=StopDBCluster';
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=StopDBCluster"]
                                                       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=StopDBCluster" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/?Action=&Version=#Action=StopDBCluster",
  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=StopDBCluster');

echo $response->getBody();
setUrl('{{baseUrl}}/#Action=StopDBCluster');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'Action' => '',
  'Version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/#Action=StopDBCluster');
$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=StopDBCluster' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/?Action=&Version=#Action=StopDBCluster' -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=StopDBCluster"

querystring = {"Action":"","Version":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/#Action=StopDBCluster"

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=StopDBCluster")

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=StopDBCluster";

    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=StopDBCluster'
http POST '{{baseUrl}}/?Action=&Version=#Action=StopDBCluster'
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/?Action=&Version=#Action=StopDBCluster'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/?Action=&Version=#Action=StopDBCluster")! 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()